partisan 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 915b00e7ddd9b09bc6a7e260e56d475a45b8daaf
+  data.tar.gz: affbbc560d7a023b40b85216ac65b035490a793c
+SHA512:
+  metadata.gz: 3d1c0843ee2e7ce9c1558490f6ea37b6fdf3911a0af79959f1343a627163ec430293951233104b67438bdd59414fe32519054684d16321a64d9aec97ddf71ef1
+  data.tar.gz: df350de0310c0a71e68bb752d8986afc74fa0e0f5f878aefbde51782f37933c059b11dbb6b8d797ce683a68a0c9b9ffc2bc751a70dae56ae80fd7298119b9257

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rémi Prévost
+
+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,101 @@
+# Partisan
+
+Partisan is a Ruby library that allows ActiveRecord records to be follower and followable
+
+It’s heavily inspired by `acts_as_follower`.
+
+It’s not 100% compatible with `acts_as_follower`, I removed some "features":
+
+* block follower
+* Array with all types of followers/following
+* `*_count` methods
+
+But I also added awesome new ones:
+
+* model_follower_fields: So you can do `following_team_ids` but also `following_team_names`. It takes advantage of the `pluck` method, so it doesn’t create an instance of each follower. (go check `pluck` documentation, it’s simply awesome).
+
+* followers/followings now returns ActiveRecord::Relation for easy chaining/scoping/paginating...
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'partisan'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Run the migration to add the `follows` table:
+
+```bash
+$ rails generate partisan:install
+```
+
+## Usage
+
+Create a couple of models.
+
+```ruby
+class Fan < ActiveRecord::Base
+  acts_as_follower
+end
+
+class Band < ActiveRecord::Base
+  acts_as_followable
+end
+```
+
+And follow/unfollow other records!
+
+```ruby
+fan = Fan.find(1)
+band = Band.find(2)
+
+fan.follow(band)
+fan.following_bands
+# => [<Band id=2>]
+
+fan.following?(band)
+# => true
+
+fan.unfollow(band)
+fan.following?(band)
+# => false
+
+```
+
+Most of the times, you would want to get a quick look at about how many bands followed a certain resource. That could be an expensive operation.
+
+However, if the *followed* record has an `followers_count` column, Partisan will populate its value with how many bands followed that record.
+
+```ruby
+band.follow(band)
+
+band.followers.count
+# SQL query that counts records and returns `1`
+
+band.followers_count
+# Quick lookup into the column and returns `1`
+```
+
+The same concept applies to `followable` with a `following_count` column
+
+## License
+
+`Partisan` is © 2013 [Mirego](http://www.mirego.com) and may be freely distributed under the [New BSD license](http://opensource.org/licenses/BSD-3-Clause).  See the [`LICENSE.md`](https://github.com/mirego/emotions/blob/master/LICENSE.md) file.
+
+## About Mirego
+
+Mirego is a team of passionate people who believe that work is a place where you can innovate and have fun.
+We proudly built mobile applications for
+[iPhone](http://mirego.com/en/iphone-app-development/ "iPhone application development"),
+[iPad](http://mirego.com/en/ipad-app-development/ "iPad application development"),
+[Android](http://mirego.com/en/android-app-development/ "Android application development"),
+[Blackberry](http://mirego.com/en/blackberry-app-development/ "Blackberry application development"),
+[Windows Phone](http://mirego.com/en/windows-phone-app-development/ "Windows Phone application development") and
+[Windows 8](http://mirego.com/en/windows-8-app-development/ "Windows 8 application development").

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc 'Run all specs'
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = 'spec/**/*_spec.rb'
+end

data/lib/generators/partisan/USAGE

@@ -0,0 +1,3 @@
+Description:
+  The acts_as_follower:install generator generates a migration that will
+  create the `follows` table in your database.

data/lib/generators/partisan/install_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Partisan
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+
+      # Implement the required interface for Rails::Generators::Migration.
+      # taken from http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+      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/add_follows_migration.rb'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+class AddFollowsMigration < ActiveRecord::Migration
+  def up
+    create_table :follows do |t|
+      t.references :followable, polymorphic: true
+      t.references :follower, polymorphic: true
+
+      t.timestamps
+    end
+
+    add_index :follows, ["follower_id", "follower_type"],     name: "fk_follows"
+    add_index :follows, ["followable_id", "followable_type"], name: "fk_followables"
+  end
+
+  def down
+    drop_table :follows
+  end
+end

data/lib/partisan.rb

@@ -0,0 +1,15 @@
+require "partisan/version"
+
+require "active_record"
+
+require "partisan/follow"
+require "partisan/follow_helper"
+require "partisan/follower"
+require "partisan/followable"
+
+module Partisan
+
+  include Partisan::FollowHelper
+end
+
+require 'partisan/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3

data/lib/partisan/follow.rb

@@ -0,0 +1,24 @@
+module Partisan
+  class Follow < ActiveRecord::Base
+    self.table_name = 'follows'
+
+    # Validations
+    validates :followable, presence: true
+    validates :follower, presence: true
+
+    # Associations
+    belongs_to :followable, polymorphic: true
+    belongs_to :follower, polymorphic: true
+
+    # Callbacks
+    after_create :update_follow_counter
+    after_destroy :update_follow_counter
+
+  protected
+
+    def update_follow_counter
+      self.follower.update_follow_counter
+      self.followable.update_follow_counter
+    end
+  end
+end

data/lib/partisan/follow_helper.rb

@@ -0,0 +1,15 @@
+module Partisan
+  module FollowHelper
+
+  private
+
+    # Retrieves the parent class name if using STI.
+    def parent_class_name(obj)
+      klass = obj.class
+      klass = klass.superclass while klass.superclass != ActiveRecord::Base
+
+      klass.name
+    end
+
+  end
+end

data/lib/partisan/followable.rb

@@ -0,0 +1,70 @@
+module Partisan
+  module Followable
+    extend ActiveSupport::Concern
+    include Partisan::FollowHelper
+
+    included do
+      has_many :followings, as: :followable, class_name: 'Partisan::Follow', dependent: :destroy
+    end
+
+    # Return true or false if the resource is following another
+    #
+    # @example
+    #
+    #   @team.followed_by?(@user)
+    #
+    # @return (Boolean)
+    def followed_by?(resource)
+      resource.following?(self)
+    end
+
+    # Get resource records for a specific type, used by #method_missing
+    # It conveniently returns an ActiveRecord::Relation for easy chaining of useful ActiveRecord methods
+    #
+    # @example
+    #
+    #   @team.followers_by_type('User')
+    #
+    # @return (ActiveRecord::Relation)
+    def followers_by_type(follower_type)
+      opts = {
+        'follows.followable_id' => self.id,
+        'follows.followable_type' => parent_class_name(self)
+      }
+
+      follower_type.constantize.joins(:follows).where(opts)
+    end
+
+    # Get ids of resources following self
+    # Use #pluck for an optimized sql query
+    #
+    # @example
+    #
+    #   @team.following_ids_by_type('User')
+    #
+    # @return (Array)
+    def follower_fields_by_type(follower_type, follower_field)
+      followers_by_type(follower_type).pluck("#{follower_type.tableize}.#{follower_field}")
+    end
+
+    # Update cache counter
+    # Called in after_create and after_destroy
+    def update_follow_counter
+      self.update_attribute('followers_count', self.followings.count) if self.respond_to?(:followers_count)
+    end
+
+    def method_missing(m, *args)
+      if m.to_s[/(.+)_follower_(.+)s$/]
+        follower_fields_by_type($1.singularize.classify, $2)
+      elsif m.to_s[/(.+)_followers$/]
+        followers_by_type($1.singularize.classify)
+      else
+        super
+      end
+    end
+
+    def respond_to?(m, include_private = false)
+      super || m.to_s[/(.+)_follower_(.+)s$/] || m.to_s[/(.+)_follower/]
+    end
+  end
+end

data/lib/partisan/follower.rb

@@ -0,0 +1,113 @@
+module Partisan
+  module Follower
+    extend ActiveSupport::Concern
+    include Partisan::FollowHelper
+
+    included do
+      has_many :follows, as: :follower, class_name: 'Partisan::Follow', dependent: :destroy
+    end
+
+    # Add follow record if it doesn’t exist
+    #
+    # @example
+    #
+    #   @user.follow(@team)
+    #
+    # @return (Partisan::Follow)
+    def follow(resource)
+      return if self == resource
+
+      fetch_follows(resource).first_or_create
+    end
+    alias_method :start_following, :follow
+
+    # Delete follow record if it exists
+    #
+    # @example
+    #
+    #   @user.unfollow(@team)
+    #
+    # @return (Partisan::Follow) || nil
+    def unfollow(resource)
+      return if self == resource
+
+      record = fetch_follows(resource).first
+      record.try(:destroy)
+    end
+    alias_method :stop_following, :unfollow
+
+    # Return true or false if the resource is following another
+    #
+    # @example
+    #
+    #   @user.following?(@team)
+    #
+    # @return (Boolean)
+    def following?(resource)
+      return false if self == resource
+
+      fetch_follows(resource).exists?
+    end
+
+    # Get all follows record related to a resource
+    #
+    # @example
+    #
+    #   @user.fetch_follows(@team)
+    #
+    # @return [Partisan::Follow, ...]
+    def fetch_follows(resource)
+      follows.where followable_id: resource.id, followable_type: parent_class_name(resource)
+    end
+
+    # Get resource records for a specific type, used by #method_missing
+    # It conveniently returns an ActiveRecord::Relation for easy chaining of useful ActiveRecord methods
+    #
+    # @example
+    #
+    #   @user.following_by_type('Team')
+    #
+    # @return (ActiveRecord::Relation)
+    def following_by_type(followable_type)
+      opts = {
+        'follows.follower_id' => self.id,
+        'follows.follower_type' => parent_class_name(self)
+      }
+
+      followable_type.constantize.joins(:followings).where(opts)
+    end
+
+    # Get ids of resources following self
+    # Use #pluck for an optimized sql query
+    #
+    # @example
+    #
+    #   @user.following_ids_by_type('Team')
+    #
+    # @return (Array)
+    def following_fields_by_type(followable_type, followable_field)
+      following_by_type(followable_type).pluck("#{followable_type.tableize}.#{followable_field}")
+    end
+
+    # Update cache counter
+    # Called in after_create and after_destroy
+    def update_follow_counter
+      self.update_attribute('followings_count', self.follows.count) if self.respond_to?(:followings_count)
+    end
+
+    def method_missing(m, *args)
+      if m.to_s[/following_(.+)_(.+)s$/]
+        following_fields_by_type($1.singularize.classify, $2)
+      elsif m.to_s[/following_(.+)/]
+        following_by_type($1.singularize.classify)
+      else
+        super
+      end
+    end
+
+    def respond_to?(m, include_private = false)
+      super || m.to_s[/following_(.+)_(.+)s$/] || m.to_s[/following_(.+)/]
+    end
+
+  end
+end

data/lib/partisan/railtie.rb

@@ -0,0 +1,18 @@
+require 'acts_as_follower'
+require 'rails'
+
+module Partisan
+  class Railtie < Rails::Railtie
+    initializer "follows.active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        def self.acts_as_follower
+          self.send :include, Partisan::Follower
+        end
+
+        def self.acts_as_followable
+          self.send :include, Partisan::Followable
+        end
+      end
+    end
+  end
+end

data/lib/partisan/version.rb

@@ -0,0 +1,3 @@
+module Partisan
+  VERSION = "0.0.1"
+end

data/partisan.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'partisan/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'partisan'
+  spec.version       = Partisan::VERSION
+  spec.authors       = ['Simon Prévost']
+  spec.email         = ['sprevost@mirego.com']
+  spec.description   = 'Partisan is a Ruby library that allows ActiveRecord records to be follower and followable, just like on popular social networks. It’s heavily inspired by the origin acts_as_follower which is no longer maintened'
+  spec.summary       = 'Partisan is a Ruby library that allows ActiveRecord records to be follower and followable'
+  spec.homepage      = 'https://github.com/simonprev/partisan'
+  spec.license       = 'BSD 3-Clause'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rails', '>= 3.0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'sqlite3'
+end

data/spec/followable_spec.rb

@@ -0,0 +1,74 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe Partisan::Followable do
+  before do
+    run_migration do
+      create_table(:fans, force: true)
+      create_table(:users, force: true)
+      create_table(:concerts, force: true)
+
+      create_table(:bands, force: true) do |t|
+        t.integer :followers_count, default: 0
+      end
+    end
+
+    follower 'Fan'
+    follower 'User'
+    followable 'Band'
+    followable 'Concert'
+  end
+
+  let(:band) { Band.create }
+  let(:user) { User.create }
+  let(:concert) { Concert.create }
+  let(:fan) { Fan.create }
+
+  describe :InstanceMethods do
+    before do
+      user.follow band
+
+      band.reload
+    end
+
+    describe :followed_by? do
+      it { expect(band.followed_by? user).to be_true }
+      it { expect(concert.followed_by? user).to be_false }
+    end
+
+    describe :followers_by_type do
+      it { expect(band.followers_by_type('User').count).to eq 1 }
+      it { expect(band.followers_by_type('User')).to be_an_instance_of(ActiveRecord::Relation) }
+      it { expect(band.followers_by_type('User').first).to be_an_instance_of(User) }
+      it { expect(band.followers_by_type('Fan').count).to eq 0 }
+    end
+
+    describe :following_fields_by_type do
+      it { expect(band.follower_fields_by_type('User', 'id').count).to eq 1 }
+      it { expect(band.follower_fields_by_type('User', 'id').first).to eq user.id }
+      it { expect(band.follower_fields_by_type('Fan', 'id').count).to eq 0 }
+    end
+
+    describe :followers_by_type_in_method_missing do
+      it { expect(band.user_followers.count).to eq 1 }
+      it { expect(band.user_followers).to be_an_instance_of(ActiveRecord::Relation) }
+      it { expect(band.user_followers.first).to be_an_instance_of(User) }
+      it { expect(band.fan_followers.count).to eq 0 }
+    end
+
+    describe :following_fields_by_type_in_method_missing do
+      it { expect(band.users_follower_ids.count).to eq 1 }
+      it { expect(band.users_follower_ids.first).to eq user.id }
+      it { expect(band.fans_follower_ids.count).to eq 0 }
+    end
+
+    describe :respond_to? do
+      it { expect(band.respond_to?(:user_followers)).to be_true }
+      it { expect(band.respond_to?(:users_follower_ids)).to be_true }
+    end
+
+    describe :update_follow_counter do
+      it { expect(band.followers_count).to eq 1 }
+    end
+  end
+end
+

data/spec/follower_spec.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe Partisan::Follower do
+  before do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.integer :followings_count, default: 0
+      end
+      create_table(:concerts, force: true)
+      create_table(:bands, force: true)
+    end
+
+    follower 'User'
+    followable 'Band'
+    followable 'Concert'
+  end
+
+  let(:band) { Band.create }
+  let(:user) { User.create }
+  let(:concert) { Concert.create }
+
+  describe :InstanceMethods do
+    before do
+      user.follow band
+
+      user.reload
+    end
+
+    describe :follow do
+      it { expect(Partisan::Follow.last.follower_id).to eq user.id }
+      it { expect(Partisan::Follow.last.followable_id).to eq band.id }
+    end
+
+    describe :unfollow do
+      it { expect{user.unfollow band}.to change{Partisan::Follow.last}.to(nil) }
+    end
+
+    describe :following? do
+      let(:band2) { Band.create }
+
+      it { expect(user.following? band).to be_true }
+      it { expect(user.following? band2).to be_false }
+    end
+
+    describe :following_by_type do
+      it { expect(user.following_by_type('Band').count).to eq 1 }
+      it { expect(user.following_by_type('Band')).to be_an_instance_of(ActiveRecord::Relation) }
+      it { expect(user.following_by_type('Band').first).to be_an_instance_of(Band) }
+      it { expect(user.following_by_type('Concert').count).to eq 0 }
+    end
+
+    describe :following_fields_by_type do
+      it { expect(user.following_fields_by_type('Band', 'id').count).to eq 1 }
+      it { expect(user.following_fields_by_type('Band', 'id').first).to eq band.id }
+      it { expect(user.following_fields_by_type('Concert', 'id').count).to eq 0 }
+    end
+
+    describe :following_by_type_in_method_missing do
+      it { expect(user.following_bands.count).to eq 1 }
+      it { expect(user.following_bands).to be_an_instance_of(ActiveRecord::Relation) }
+      it { expect(user.following_bands.first).to be_an_instance_of(Band) }
+
+      it { expect(user.following_concerts.count).to eq 0 }
+      it { expect(user.following_concerts).to be_an_instance_of(ActiveRecord::Relation) }
+    end
+
+    describe :following_fields_by_type_in_method_missing do
+      it { expect(user.following_band_ids.count).to eq 1 }
+      it { expect(user.following_band_ids.first).to eq band.id }
+      it { expect(user.following_concert_ids.count).to eq 0 }
+    end
+
+    describe :update_follow_counter do
+      it { expect(user.followings_count).to eq 1 }
+    end
+
+    describe :respond_to? do
+      it { expect(user.respond_to?(:following_bands)).to be_true }
+      it { expect(user.respond_to?(:following_band_ids)).to be_true }
+    end
+  end
+
+  describe :AliasMethods do
+    subject { User.create }
+
+    it { should respond_to :start_following }
+    it { should respond_to :stop_following }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'rspec'
+require 'sqlite3'
+
+require 'partisan'
+
+# Require our macros and extensions
+Dir[File.expand_path('../../spec/support/macros/*.rb', __FILE__)].map(&method(:require))
+Dir[File.expand_path('../../spec/support/extensions/*.rb', __FILE__)].map(&method(:require))
+
+
+RSpec.configure do |config|
+  # Include our macros
+  config.include DatabaseMacros
+  config.include ModelMacros
+
+  config.before(:each) do
+    # Create the SQLite database
+    setup_database
+
+    # Run our migration
+    run_default_migration
+  end
+
+  config.after(:each) do
+    # Make sure we remove our test database file
+    cleanup_database
+  end
+end

data/spec/support/extensions/active_record.rb

@@ -0,0 +1,9 @@
+class ActiveRecord::Base
+  def self.acts_as_follower
+    self.send :include, Partisan::Follower
+  end
+
+  def self.acts_as_followable
+    self.send :include, Partisan::Followable
+  end
+end

data/spec/support/macros/database_macros.rb

@@ -0,0 +1,39 @@
+module DatabaseMacros
+  # Run migrations in the test database
+  def run_migration(&block)
+    # Create a new migration class
+    klass = Class.new(ActiveRecord::Migration)
+
+    # Create a new `up` that executes the argument
+    klass.send(:define_method, :up) { self.instance_exec(&block) }
+
+    # Create a new instance of it and execute its `up` method
+    klass.new.up
+  end
+
+  def self.database_file
+    @database_file || File.join(File.dirname(__FILE__), 'test.db')
+  end
+
+  def setup_database
+    # Make sure the test database file is gone
+    cleanup_database
+
+    # Establish the connection
+    SQLite3::Database.new FileUtils.touch(DatabaseMacros.database_file).first
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: DatabaseMacros.database_file)
+
+    # Silence everything
+    ActiveRecord::Base.logger = ActiveRecord::Migration.verbose = false
+  end
+
+  def cleanup_database
+    FileUtils.rm(DatabaseMacros.database_file) if File.exists?(DatabaseMacros.database_file)
+  end
+
+  # Run the built-in migration
+  def run_default_migration
+    load File.join(File.dirname(__FILE__), '../../../lib/generators/partisan/templates/migration.rb')
+    AddFollowsMigration.new.up
+  end
+end

data/spec/support/macros/model_macros.rb

@@ -0,0 +1,26 @@
+module ModelMacros
+  # Create a new emotional model
+  def followable(klass_name, &block)
+    spawn_model klass_name, ActiveRecord::Base do
+      acts_as_followable
+      instance_exec(&block) if block
+    end
+  end
+
+  # Create a new emotive model
+  def follower(klass_name, &block)
+    spawn_model klass_name, ActiveRecord::Base do
+      acts_as_follower
+      class_eval(&block) if block
+    end
+  end
+
+  protected
+
+  # Create a new model class
+  def spawn_model(klass_name, parent_klass, &block)
+    Object.instance_eval { remove_const klass_name } if Object.const_defined?(klass_name)
+    Object.const_set(klass_name, Class.new(parent_klass))
+    Object.const_get(klass_name).class_eval(&block) if block_given?
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: partisan
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Simon Prévost
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Partisan is a Ruby library that allows ActiveRecord records to be follower
+  and followable, just like on popular social networks. It’s heavily inspired by the
+  origin acts_as_follower which is no longer maintened
+email:
+- sprevost@mirego.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/partisan/USAGE
+- lib/generators/partisan/install_generator.rb
+- lib/generators/partisan/templates/migration.rb
+- lib/partisan.rb
+- lib/partisan/follow.rb
+- lib/partisan/follow_helper.rb
+- lib/partisan/followable.rb
+- lib/partisan/follower.rb
+- lib/partisan/railtie.rb
+- lib/partisan/version.rb
+- partisan.gemspec
+- spec/followable_spec.rb
+- spec/follower_spec.rb
+- spec/spec_helper.rb
+- spec/support/extensions/active_record.rb
+- spec/support/macros/database_macros.rb
+- spec/support/macros/model_macros.rb
+homepage: https://github.com/simonprev/partisan
+licenses:
+- BSD 3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Partisan is a Ruby library that allows ActiveRecord records to be follower
+  and followable
+test_files:
+- spec/followable_spec.rb
+- spec/follower_spec.rb
+- spec/spec_helper.rb
+- spec/support/extensions/active_record.rb
+- spec/support/macros/database_macros.rb
+- spec/support/macros/model_macros.rb