acts_as_followable 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [Kristijan Sedlak]
+
+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,86 @@
+= ActsAsFollowable - Model following
+
+This plugin is a Rails3 alternative of the plugin called {acts_as_follower}[https://github.com/tcocca/acts_as_follower] 
+by tcocca. It allows any model to follow other models and a model can be followed by other models.
+
+Usually you will use this plugin when implementing a blog-style website where users will follow other users or for 
+users to follow Books, etc...
+
+== Installation (Rails 3 ready)
+
+Add this line to your Gemfile (and run bundle install):
+
+  gem 'acts_as_followable'
+
+Run the generator which will generate a migration file.
+
+  script/generate acts_as_followable
+
+The plugin comes with a Follow model file. You can override the default model definition by creating a new 
+app/models/follow.rb file with the content:
+
+  class Follow < ActiveRecord::Base
+    belongs_to :followable, :polymorphic => true
+    belongs_to :follower, :polymorphic => true
+  end  
+
+== Setup
+
+If you would like a model to follow or to be followed by any other model, just add the mixin:
+  class User < ActiveRecord::Base
+    ...
+    acts_as_followable
+    ...
+  end
+
+== Examples
+
+To have an object start following another use the following: 
+
+  book = Book.find(1)
+  user = User.find(1)
+  user.follow(book)
+
+To stop following an object use the following 
+
+  user.stop_following(book)
+  
+You can check to see if an object is following another object through the following:
+
+  user.following?(book)
+
+You can check to see if an object is followed by another object through the following:
+  
+  book.followed_by?(user)
+
+To get a list of followers by a given type use the following (e.g. list of users that follow a book):
+
+  User.following(book)
+  or
+  book.followers_by_type('User')
+  or
+  book.user_followers
+  
+  # Also
+  
+  User.following(book).order('name').limit(2)
+  or
+  book.followers_by_type('User').limit(2)
+  or
+  book.user_followers.order('name')
+
+To get a list of records of a particular type which this record is following (e.g. list of books followed by a user)
+
+  Book.followed_by(user)
+  or
+  user.following_by_type('Book')
+  or
+  user.following_book
+
+  # Also
+
+  Book.followed_by(user).order('title').limit(2)
+  or
+  user.following_by_type('Book').limit(2)
+  or
+  user.following_book('title')

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_taggable_on_steroids plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_taggable_on_steroids plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Acts As Follower'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :rcov do
+
+  desc "Generate a coverage report in coverage/"
+  task :gen do
+    sh "rcov --output coverage test/*_test.rb --exclude 'gems/*'"
+  end
+
+  desc "Remove generated coverage files."
+  task :clobber do
+    sh "rm -rdf coverage"
+  end
+
+end

data/lib/acts_as_followable/followable.rb

@@ -0,0 +1,84 @@
+module ActsAsFollowable
+  module Followable
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_followable
+        include ActsAsFollowable::Followable::InstanceMethods
+        
+        scope :following, lambda{|followable| includes(:follows).where(['follows.followable_id=? AND follows.followable_type=?', followable.id, followable.class.name]) }
+        scope :followed_by, lambda{|follower| includes(:followings).where(['follows.follower_id=? AND follows.follower_type=?', follower.id, follower.class.name]) }
+        
+        has_many :followings, :as => :followable, :dependent => :destroy, :class_name => 'Follow'
+        has_many :follows, :as => :follower, :dependent => :destroy
+      end
+    end
+
+    module InstanceMethods
+      
+      # Returns the followers by a given type
+      def followers_by_type(type)
+        type.constantize.following(self)
+      end
+
+      # Returns the actual records of a particular type which this record is following.
+      def following_by_type(type)
+        type.constantize.followed_by(self)
+      end
+
+      # Allows magic names on followers_by_type
+      # e.g. followers_by_type('User') > user_followers
+      # e.g. following_by_type('User') > following_user
+      def method_missing(m, *args)
+        if m.to_s[/(.+)_followers/]
+          followers_by_type($1.singularize.classify)
+        elsif m.to_s[/following_(.+)/]
+          following_by_type($1.singularize.classify)
+        else
+          super
+        end
+      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 = follow_for_follawable(followable).first
+        if follow.blank? && self != followable
+          Follow.create(:followable => followable, :follower => self)
+        end
+      end
+
+      # Returns true if this instance is following the object passed as an argument.
+      def following?(followable)
+        0 < follow_for_follawable(followable).limit(1).count
+      end
+
+      # Deletes the follow record if it exists.
+      def stop_following(followable)
+        if follow = follow_for_follawable(followable).first
+          follow.destroy
+        end
+      end
+
+      # Returns true if the current instance is followed by the passed record
+      def followed_by?(follower)
+        0 < follow_for_follower(follower).limit(1).count
+      end
+      
+      private
+      
+      def follow_for_follawable(followable)
+        Follow.where(["follower_id = ? AND follower_type = ? AND followable_id = ? AND followable_type = ?", self.id, self.class.name, followable.id, followable.class.name])
+      end
+      
+      def follow_for_follower(follower)
+        Follow.where(["follower_id = ? AND follower_type = ? AND followable_id = ? AND followable_type = ?", follower.id, follower.class.name, self.id, self.class.name])
+      end
+      
+    end
+
+  end
+end

data/lib/acts_as_followable/version.rb

@@ -0,0 +1,9 @@
+module ActsAsFollowable
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/acts_as_followable.rb

@@ -0,0 +1,7 @@
+%w( acts_as_followable/version
+    acts_as_followable/followable
+).each do |lib|
+    require File.join(File.dirname(__FILE__), lib)
+end
+
+ActiveRecord::Base.send(:include, ActsAsFollowable::Followable)

data/lib/generators/USAGE

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

data/lib/generators/acts_as_followable_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class ActsAsFollowableGenerator < 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_followable_migration.rb'
+  end
+  
+end

data/lib/generators/templates/migration.rb

@@ -0,0 +1,16 @@
+class ActsAsFollowableMigration < 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.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/test/TESTING

@@ -0,0 +1,48 @@
+Testing
+==============
+
+Tests are written with Shoulda on top of Test::Unit and Factory Girl is used instead of fixtures.  Tests are run using rake.
+Test can either be run against a MySQL database or the faster in-memory SQLite3.
+
+
+MySQL
+=======
+
+1. Create a new Rails app.
+2. Install acts_as_follower as a plugin.
+3. Copy the database config within the plugin:
+    cp test/database.yml.example test/database.yml
+4. Create a database as specified in test/database.yml.
+5. Run the tests:
+    rake test
+
+
+SQLite3
+=======
+
+1. Create a new Rails app.
+2. Install acts_as_follower as a plugin.
+3. Copy the database config within the plugin:
+    cp test/database.yml.example test/database.yml
+4. Install the sqlite3 library (if you don't have it already):
+    sudo gem install sqlite3-ruby
+5. Run the tests:
+    DB=sqlite3 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   # For mysql
+
+or:
+
+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

data/test/database.yml.example

@@ -0,0 +1,10 @@
+mysql:
+  adapter: mysql
+  host: localhost
+  username: root
+  password:
+  database: rails_plugin_test
+
+sqlite3:
+  adapter: sqlite3
+  database: ':memory:'

data/test/follow_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FollowTest < ActiveSupport::TestCase
+
+  # Replace with real tests
+  def test_assert_true_should_be_true
+    assert true
+  end
+
+end

data/test/models/band.rb

@@ -0,0 +1,4 @@
+class Band < ActiveRecord::Base
+  validates_presence_of :name
+  acts_as_followable
+end

data/test/models/user.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  validates_presence_of :name
+  acts_as_followable
+end

data/test/schema.rb

@@ -0,0 +1,21 @@
+ActiveRecord::Schema.define :version => 0 do
+
+  create_table :follows, :force => true do |t|
+    t.integer  "followable_id",   :null => false
+    t.string   "followable_type", :null => false
+    t.integer  "follower_id",     :null => false
+    t.string   "follower_type",   :null => false
+    t.boolean  "blocked", :default => false, :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table :users, :force => true do |t|
+    t.column :name, :string
+  end
+
+  create_table :bands, :force => true do |t|
+    t.column :name, :string
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'logger'
+require 'active_record'
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+ActiveRecord::Base.configurations = YAML::load(File.open(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'mysql')
+
+require File.dirname(__FILE__) + '/../init.rb'
+require File.dirname(__FILE__) + '/models/band'
+require File.dirname(__FILE__) + '/models/user'
+require File.dirname(__FILE__) + '/../lib/generators/templates/model.rb'
+
+require 'test/unit'
+require 'active_support'
+require 'shoulda'
+require 'factory_girl'
+Factory.find_definitions
+
+load(File.dirname(__FILE__) + '/schema.rb')

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_followable
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kristijan Sedlak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-10 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Implements the following functionality where one model can be followed by other models and and vice versa.
+email: xpepermint@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- Rakefile
+- lib/acts_as_followable/followable.rb
+- lib/acts_as_followable/version.rb
+- lib/acts_as_followable.rb
+- lib/generators/acts_as_followable_generator.rb
+- lib/generators/templates/migration.rb
+- lib/generators/USAGE
+- test/acts_as_followable_test.rb
+- test/database.yml.example
+- test/factories/bands.rb
+- test/factories/users.rb
+- test/follow_test.rb
+- test/models/band.rb
+- test/models/user.rb
+- test/schema.rb
+- test/test_helper.rb
+- test/TESTING
+- README.rdoc
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://github.com/xpepermint/acts_as_followable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ActsAsFollowable - Model following.
+test_files: []
+