acts_as_follower 0.1.0

data/lib/acts_as_follower/follower.rb

@@ -0,0 +1,100 @@
+module ActsAsFollower #:nodoc:
+  module Follower
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_follower
+        has_many :follows, :as => :follower, :dependent => :destroy
+        include ActsAsFollower::Follower::InstanceMethods
+        include ActsAsFollower::FollowerLib
+      end
+    end
+
+    module InstanceMethods
+
+      # Returns true if this instance is following the object passed as an argument.
+      def following?(followable)
+        0 < Follow.unblocked.for_follower(self).for_followable(followable).count
+      end
+
+      # Returns the number of objects this instance is following.
+      def follow_count
+        Follow.unblocked.for_follower(self).count
+      end
+
+      # Creates a new follow record for this instance to follow the passed object.
+      # Does not allow duplicate records to be created.
+      def follow(followable)
+        follow = get_follow(followable)
+        if follow.blank? && self != followable
+          Follow.create(:followable => followable, :follower => self)
+        end
+      end
+
+      # Deletes the follow record if it exists.
+      def stop_following(followable)
+        if follow = get_follow(followable)
+          follow.destroy
+        end
+      end
+
+      # Returns the follow records related to this instance by type.
+      def follows_by_type(followable_type, options={})
+        Follow.unblocked.includes(:followable).for_follower(self).for_followable_type(followable_type).find(:all, options)
+      end
+
+      # Returns the follow records related to this instance with the followable included.
+      def all_follows(options={})
+        self.follows.unblocked.includes(:followable).all(options)
+      end
+
+      # Returns the actual records which this instance is following.
+      def all_following(options={})
+        all_follows(options).collect{ |f| f.followable }
+      end
+
+      # Returns the actual records of a particular type which this record is following.
+      def following_by_type(followable_type, options={})
+        follows = followable_type.constantize.
+          includes(:followings).
+          where('blocked = ?', false).
+          where(
+            "follows.follower_id = ? AND follows.follower_type = ? AND follows.followable_type = ?", 
+            self.id, parent_class_name(self), followable_type
+          )
+        if options.has_key?(:limit)
+          follows = follows.limit(options[:limit])
+        end
+        follows
+      end
+
+      def following_by_type_count(followable_type)
+        Follow.unblocked.for_follower(self).for_followable_type(followable_type).count
+      end
+
+      # Allows magic names on following_by_type
+      # e.g. following_users == following_by_type('User')
+      # Allows magic names on following_by_type_count
+      # e.g. following_users_count == following_by_type_count('User')
+      def method_missing(m, *args)
+        if m.to_s[/following_(.+)_count/]
+          following_by_type_count($1.singularize.classify)
+        elsif m.to_s[/following_(.+)/]
+          following_by_type($1.singularize.classify)
+        else
+          super
+        end
+      end
+
+      # Returns a follow record for the current instance and followable object.
+      def get_follow(followable)
+        Follow.unblocked.for_follower(self).for_followable(followable).first
+      end
+
+    end
+
+  end
+end

data/lib/acts_as_follower/follower_lib.rb

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

data/lib/acts_as_follower/railtie.rb

@@ -0,0 +1,15 @@
+require 'acts_as_follower'
+require 'rails'
+
+module ActsAsFollower
+  class Railtie < Rails::Railtie
+    
+    initializer "acts_as_follower.active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        include ActsAsFollower::Follower
+        include ActsAsFollower::Followable
+      end
+    end
+    
+  end
+end

data/lib/acts_as_follower/version.rb

@@ -0,0 +1,3 @@
+module ActsAsFollower
+  VERSION = "0.1.0"
+end

data/lib/generators/USAGE

@@ -0,0 +1,5 @@
+Description:
+    rails generate acts_as_follower
+
+    no need to specify a name after acts_as_follower as you can not change the model name from Follow
+    the acts_as_follower_migration file will be created in db/migrate

data/lib/generators/acts_as_follower_generator.rb

@@ -0,0 +1,30 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class ActsAsFollowerGenerator < Rails::Generators::Base
+  
+  include Rails::Generators::Migration
+  
+  def self.source_root
+    @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+  
+  # 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/acts_as_follower_migration.rb'
+  end
+  
+  def create_model
+    template "model.rb", File.join('app/models', "follow.rb")
+  end
+  
+end

data/lib/generators/templates/migration.rb

@@ -0,0 +1,17 @@
+class ActsAsFollowerMigration < ActiveRecord::Migration
+  def self.up
+    create_table :follows, :force => true do |t|
+      t.references :followable, :polymorphic => true, :null => false
+      t.references :follower,   :polymorphic => true, :null => false
+      t.boolean :blocked, :default => false, :null => false
+      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 self.down
+    drop_table :follows
+  end
+end

data/lib/generators/templates/model.rb

@@ -0,0 +1,21 @@
+class Follow < ActiveRecord::Base
+  extend ActsAsFollower::FollowerLib
+  
+  scope :for_follower,        lambda { |follower| where(["follower_id = ? AND follower_type = ?", follower.id, parent_class_name(follower)]) }
+  scope :for_followable,      lambda { |followable| where(["followable_id = ? AND followable_type = ?", followable.id, parent_class_name(followable)]) }
+  scope :for_follower_type,   lambda { |follower_type| where("follower_type = ?", follower_type) }
+  scope :for_followable_type, lambda { |followable_type| where("followable_type = ?", followable_type) }
+  scope :recent,              lambda { |from| where(["created_at > ?", (from || 2.weeks.ago).to_s(:db)]) }
+  scope :descending,          order("follows.created_at DESC")
+  scope :unblocked,           where(:blocked => false)
+  scope :blocked,             where(:blocked => true)
+  
+  # NOTE: Follows belong to the "followable" interface, and also to followers
+  belongs_to :followable, :polymorphic => true
+  belongs_to :follower,   :polymorphic => true
+  
+  def block!
+    self.update_attribute(:blocked, true)
+  end
+  
+end

data/test/README

@@ -0,0 +1,24 @@
+Testing
+=======
+
+Tests are written with Shoulda on top of Test::Unit and Factory Girl is used instead of fixtures.  Tests are run using rake.
+
+1. Clone your fork git locally.
+2. Install the dependencies
+    $ bundle install
+3. Run the tests:
+    rake test
+
+
+Coverage
+=======
+
+Test coverage can be calculated using Rcov. Make sure you have the rcov gem installed.
+
+Again in the acts_as_follower directory:
+
+rake rcov:gen DB=sqlite3   # For sqlite
+
+The coverage will now be available in the test/coverage directory.
+
+rake rcov:clobber will delete the coverage directory.

data/test/acts_as_followable_test.rb

@@ -0,0 +1,241 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ActsAsFollowableTest < ActiveSupport::TestCase
+
+  context "instance methods" do
+    setup do
+      @sam = Factory(:sam)
+    end
+
+    should "be defined" do
+      assert @sam.respond_to?(:followers_count)
+      assert @sam.respond_to?(:followers)
+      assert @sam.respond_to?(:followed_by?)
+    end
+  end
+
+  context "acts_as_followable" do
+    setup do
+      @sam = Factory(:sam)
+      @jon = Factory(:jon)
+      @oasis = Factory(:oasis)
+      @metallica = Factory(:metallica)
+      @sam.follow(@jon)
+    end
+
+    context "followers_count" do
+      should "return the number of followers" do
+        assert_equal 0, @sam.followers_count
+        assert_equal 1, @jon.followers_count
+      end
+
+      should "return the proper number of multiple followers" do
+        @bob = Factory(:bob)
+        @sam.follow(@bob)
+        assert_equal 0, @sam.followers_count
+        assert_equal 1, @jon.followers_count
+        assert_equal 1, @bob.followers_count
+      end
+    end
+
+    context "followers" do
+      should "return users" do
+        assert_equal [], @sam.followers
+        assert_equal [@sam], @jon.followers
+      end
+
+      should "return users (multiple followers)" do
+        @bob = Factory(:bob)
+        @sam.follow(@bob)
+        assert_equal [], @sam.followers
+        assert_equal [@sam], @jon.followers
+        assert_equal [@sam], @bob.followers
+      end
+
+      should "return users (multiple followers, complex)" do
+        @bob = Factory(:bob)
+        @sam.follow(@bob)
+        @jon.follow(@bob)
+        assert_equal [], @sam.followers
+        assert_equal [@sam], @jon.followers
+        assert_equal [@sam, @jon], @bob.followers
+      end
+
+      should "accept AR options" do
+        @bob = Factory(:bob)
+        @bob.follow(@jon)
+        assert_equal 1, @jon.followers(:limit => 1).count
+      end
+    end
+
+    context "followed_by" do
+      should "return_follower_status" do
+        assert_equal true, @jon.followed_by?(@sam)
+        assert_equal false, @sam.followed_by?(@jon)
+      end
+    end
+
+    context "destroying a followable" do
+      setup do
+        @jon.destroy
+      end
+
+      should_change("follow count", :by => -1) { Follow.count }
+      should_change("@sam.all_following.size", :by => -1) { @sam.all_following.size }
+    end
+
+    context "blocks" do
+      setup do
+        @bob = Factory(:bob)
+        @jon.block(@sam)
+        @jon.block(@bob)
+      end
+
+      should "accept AR options" do
+        assert_equal 1, @jon.blocks(:limit => 1).count
+      end
+    end
+
+    context "blocking a follower" do
+      context "in my following list" do
+        setup do
+          @jon.block(@sam)
+        end
+
+        should "remove him from followers" do
+          assert_equal 0, @jon.followers_count
+        end
+
+        should "add him to the blocked followers" do
+          assert_equal 1, @jon.blocked_followers_count
+        end
+
+        should "not be able to follow again" do
+          @jon.follow(@sam)
+          assert_equal 0, @jon.followers_count
+        end
+
+        should "not be present when listing followers" do
+          assert_equal [], @jon.followers
+        end
+
+        should "be in the list of blocks" do
+          assert_equal [@sam], @jon.blocks
+        end
+      end
+
+      context "not in my following list" do
+        setup do
+          @sam.block(@jon)
+        end
+
+        should "add him to the blocked followers" do
+          assert_equal 1, @sam.blocked_followers_count
+        end
+
+        should "not be able to follow again" do
+          @sam.follow(@jon)
+          assert_equal 0, @sam.followers_count
+        end
+
+        should "not be present when listing followers" do
+          assert_equal [], @sam.followers
+        end
+
+        should "be in the list of blocks" do
+          assert_equal [@jon], @sam.blocks
+        end
+      end
+    end
+
+    context "unblocking a blocked follow" do
+      setup do
+        @jon.block(@sam)
+        @jon.unblock(@sam)
+      end
+
+      should "not include the unblocked user in the list of followers" do
+        assert_equal [], @jon.followers
+      end
+
+      should "remove him from the blocked followers" do
+        assert_equal 0, @jon.blocked_followers_count
+        assert_equal [], @jon.blocks
+      end
+    end
+
+    context "unblock a non-existent follow" do
+      setup do
+        @sam.stop_following(@jon)
+        @jon.unblock(@sam)
+      end
+
+      should "not be in the list of followers" do
+        assert_equal [], @jon.followers
+      end
+
+      should "not be in the blockked followers count" do
+        assert_equal 0, @jon.blocked_followers_count
+      end
+
+      should "not be in the blocks list" do
+        assert_equal [], @jon.blocks
+      end
+    end
+
+    context "followers_by_type" do
+      setup do
+        @sam.follow(@oasis)
+        @jon.follow(@oasis)
+      end
+
+      should "return the followers for given type" do
+        assert_equal [@sam], @jon.followers_by_type('User')
+        assert_equal [@sam,@jon], @oasis.followers_by_type('User')
+      end
+
+      should "not return block followers in the followers for a given type" do
+        @oasis.block(@jon)
+        assert_equal [@sam], @oasis.followers_by_type('User')
+      end
+
+      should "return the count for followers_by_type_count for a given type" do
+        assert_equal 1, @jon.followers_by_type_count('User')
+        assert_equal 2, @oasis.followers_by_type_count('User')
+      end
+
+      should "not count blocked follows in the count" do
+        @oasis.block(@sam)
+        assert_equal 1, @oasis.followers_by_type_count('User')
+      end
+    end
+
+    context "method_missing" do
+      setup do
+        @sam.follow(@oasis)
+        @jon.follow(@oasis)
+      end
+
+      should "return the followers for given type" do
+        assert_equal [@sam], @jon.user_followers
+        assert_equal [@sam,@jon], @oasis.user_followers
+      end
+
+      should "not return block followers in the followers for a given type" do
+        @oasis.block(@jon)
+        assert_equal [@sam], @oasis.user_followers
+      end
+
+      should "return the count for followers_by_type_count for a given type" do
+        assert_equal 1, @jon.count_user_followers
+        assert_equal 2, @oasis.count_user_followers
+      end
+
+      should "not count blocked follows in the count" do
+        @oasis.block(@sam)
+        assert_equal 1, @oasis.count_user_followers
+      end
+    end
+  end
+
+end