acts_as_follower1 1.0.9

data/lib/acts_as_follower/followable.rb

@@ -0,0 +1,113 @@
+module ActsAsFollower #:nodoc:
+  module Followable
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_followable
+        has_many :followings, as: :followable, dependent: :destroy, class_name: 'Follow'
+        include ActsAsFollower::Followable::InstanceMethods
+        include ActsAsFollower::FollowerLib
+      end
+    end
+
+    module InstanceMethods
+
+      # Returns the number of followers a record has.
+      def followers_count
+        self.followings.unblocked.count
+      end
+
+      # Returns the followers by a given type
+      def followers_by_type(follower_type, options={})
+        follows = follower_type.constantize.
+          joins(:follows).
+          where('follows.blocked'         => false,
+                'follows.followable_id'   => self.id,
+                'follows.followable_type' => parent_class_name(self),
+                'follows.follower_type'   => follower_type)
+        if options.has_key?(:limit)
+          follows = follows.limit(options[:limit])
+        end
+        if options.has_key?(:includes)
+          follows = follows.includes(options[:includes])
+        end
+        follows
+      end
+
+      def followers_by_type_count(follower_type)
+        self.followings.unblocked.for_follower_type(follower_type).count
+      end
+
+      # Allows magic names on followers_by_type
+      # e.g. user_followers == followers_by_type('User')
+      # Allows magic names on followers_by_type_count
+      # e.g. count_user_followers == followers_by_type_count('User')
+      def method_missing(m, *args)
+        if m.to_s[/count_(.+)_followers/]
+          followers_by_type_count($1.singularize.classify)
+        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[/count_(.+)_followers/] || m.to_s[/(.+)_followers/]
+      end
+
+      def blocked_followers_count
+        self.followings.blocked.count
+      end
+
+      # Returns the followings records scoped
+      def followers_scoped
+        self.followings.includes(:follower)
+      end
+
+      def followers(options={})
+        followers_scope = followers_scoped.unblocked
+        followers_scope = apply_options_to_scope(followers_scope, options)
+        followers_scope.to_a.collect{|f| f.follower}
+      end
+
+      def blocks(options={})
+        blocked_followers_scope = followers_scoped.blocked
+        blocked_followers_scope = apply_options_to_scope(blocked_followers_scope, options)
+        blocked_followers_scope.to_a.collect{|f| f.follower}
+      end
+
+      # Returns true if the current instance is followed by the passed record
+      # Returns false if the current instance is blocked by the passed record or no follow is found
+      def followed_by?(follower)
+        self.followings.unblocked.for_follower(follower).first.present?
+      end
+
+      def block(follower)
+        get_follow_for(follower) ? block_existing_follow(follower) : block_future_follow(follower)
+      end
+
+      def unblock(follower)
+        get_follow_for(follower).try(:delete)
+      end
+
+      def get_follow_for(follower)
+        self.followings.for_follower(follower).first
+      end
+
+      private
+
+      def block_future_follow(follower)
+        Follow.create(followable: self, follower: follower, blocked: true)
+      end
+
+      def block_existing_follow(follower)
+        get_follow_for(follower).block!
+      end
+
+    end
+  end
+end

data/lib/acts_as_follower/follower.rb

@@ -0,0 +1,112 @@
+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)
+        if self != followable
+          params = {followable_id: followable.id, followable_type: parent_class_name(followable)}
+          self.follows.where(params).first_or_create!
+        end
+      end
+
+      # Deletes the follow record if it exists.
+      def stop_following(followable)
+        if follow = get_follow(followable)
+          follow.destroy
+        end
+      end
+
+      # returns the follows records to the current instance
+      def follows_scoped
+        self.follows.unblocked.includes(:followable)
+      end
+
+      # Returns the follow records related to this instance by type.
+      def follows_by_type(followable_type, options={})
+        follows_scope  = follows_scoped.for_followable_type(followable_type)
+        follows_scope = apply_options_to_scope(follows_scope, options)
+      end
+
+      # Returns the follow records related to this instance with the followable included.
+      def all_follows(options={})
+        follows_scope = follows_scoped
+        follows_scope = apply_options_to_scope(follows_scope, 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={})
+        followables = followable_type.constantize.
+          joins(:followings).
+          where('follows.blocked'         => false,
+                'follows.follower_id'     => self.id,
+                'follows.follower_type'   => parent_class_name(self),
+                'follows.followable_type' => followable_type)
+        if options.has_key?(:limit)
+          followables = followables.limit(options[:limit])
+        end
+        if options.has_key?(:includes)
+          followables = followables.includes(options[:includes])
+        end
+        followables
+      end
+
+      def following_by_type_count(followable_type)
+        follows.unblocked.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
+
+      def respond_to?(m, include_private = false)
+        super || m.to_s[/following_(.+)_count/] || m.to_s[/following_(.+)/]
+      end
+
+      # Returns a follow record for the current instance and followable object.
+      def get_follow(followable)
+        self.follows.unblocked.for_followable(followable).first
+      end
+
+    end
+  end
+end

data/lib/acts_as_follower/follower_lib.rb

@@ -0,0 +1,42 @@
+module ActsAsFollower
+  module FollowerLib
+
+    private
+
+    DEFAULT_PARENTS = [ApplicationRecord, ActiveRecord::Base]
+
+    # Retrieves the parent class name if using STI.
+    def parent_class_name(obj)
+      unless parent_classes.include?(obj.class.superclass)
+        return obj.class.base_class.name
+      end
+      obj.class.name
+    end
+
+    def apply_options_to_scope(scope, options = {})
+      if options.has_key?(:limit)
+        scope = scope.limit(options[:limit])
+      end
+      if options.has_key?(:includes)
+        scope = scope.includes(options[:includes])
+      end
+      if options.has_key?(:joins)
+        scope = scope.joins(options[:joins])
+      end
+      if options.has_key?(:where)
+        scope = scope.where(options[:where])
+      end
+      if options.has_key?(:order)
+        scope = scope.order(options[:order])
+      end
+      scope
+    end
+
+    def parent_classes
+      return DEFAULT_PARENTS unless ActsAsFollower.custom_parent_classes
+
+      ActiveSupport::Deprecation.warn("Setting custom parent classes is deprecated and will be removed in future versions.")
+      ActsAsFollower.custom_parent_classes + DEFAULT_PARENTS
+    end
+  end
+end

data/lib/acts_as_follower/railtie.rb

@@ -0,0 +1,14 @@
+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 = "1.0.9"
+end

data/lib/acts_as_follower1.rb

@@ -0,0 +1,33 @@
+require "acts_as_follower/version"
+
+module ActsAsFollower
+  autoload :Follower,     'acts_as_follower/follower'
+  autoload :Followable,   'acts_as_follower/followable'
+  autoload :FollowerLib,  'acts_as_follower/follower_lib'
+  autoload :FollowScopes, 'acts_as_follower/follow_scopes'
+
+  def self.setup
+    @configuration ||= Configuration.new
+    yield @configuration if block_given?
+  end
+
+  def self.method_missing(method_name, *args, &block)
+    if method_name == :custom_parent_classes=
+      ActiveSupport::Deprecation.warn("Setting custom parent classes is deprecated and will be removed in future versions.")
+    end
+    @configuration.respond_to?(method_name) ?
+        @configuration.send(method_name, *args, &block) : super
+  end
+
+  class Configuration
+    attr_accessor :custom_parent_classes
+
+    def initialize
+      @custom_parent_classes = []
+    end
+  end
+
+  setup
+
+  require 'acts_as_follower/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+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 https://github.com/rails/rails/blob/master/activerecord/lib/rails/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,14 @@
+class Follow < ActiveRecord::Base
+
+  extend ActsAsFollower::FollowerLib
+  extend ActsAsFollower::FollowScopes
+
+  # NOTE: Follows belong to the "followable" and "follower" interface
+  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,283 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ActsAsFollowableTest < ActiveSupport::TestCase
+
+  context "instance methods" do
+    setup do
+      @sam = FactoryGirl.create(: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 = FactoryGirl.create(:sam)
+      @jon = FactoryGirl.create(:jon)
+      @oasis = FactoryGirl.create(:oasis)
+      @metallica = FactoryGirl.create(:metallica)
+      @green_day = FactoryGirl.create(:green_day)
+      @blink_182 = FactoryGirl.create(:blink_182)
+      @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 = FactoryGirl.create(: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 = FactoryGirl.create(: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 = FactoryGirl.create(: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 = FactoryGirl.create(: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 "get follow record" do
+      setup do
+        @bob = FactoryGirl.create(:bob)
+        @follow = @bob.follow(@sam)
+      end
+
+      should "return follow record" do
+        assert_equal @follow, @sam.get_follow_for(@bob)
+      end
+
+      should "return nil" do
+        assert_nil @sam.get_follow_for(@jon)
+      end
+    end
+
+    context "blocks" do
+      setup do
+        @bob = FactoryGirl.create(: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 blocked 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 "followers_with_sti" do
+      setup do
+        @sam.follow(@green_day)
+        @sam.follow(@blink_182)
+      end
+
+      should "return the followers for given type" do
+        assert_equal @sam.follows_by_type('Band').first.followable, @green_day.becomes(Band)
+        assert_equal @sam.follows_by_type('Band').second.followable, @blink_182.becomes(Band)
+        assert @green_day.followers_by_type('User').include?(@sam)
+        assert @blink_182.followers_by_type('User').include?(@sam)
+      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
+
+    context "respond_to?" do
+      should "advertise that it responds to following methods" do
+        assert @oasis.respond_to?(:user_followers)
+        assert @oasis.respond_to?(:user_followers_count)
+      end
+
+      should "return false when called with a nonexistent method" do
+        assert (not @oasis.respond_to?(:foobar))
+      end
+    end
+
+  end
+end