mongo_followable 0.3.0 → 0.3.2

data/README.rdoc

@@ -9,29 +9,33 @@ In console:
 or in Gemfile:
   gem 'mongo_followable'
 
+== Notice
+
+Please read following documentation first. Since 0.3.2, some apis have been changed. Sorry for the inconvenience.
+
+If you want to remove `follow_history` and `followed_history` fields totally from your database after you decide not to use follow/followed history feature, do this:
+
+    # in the rails console, taking user as an example:
+    User.all.each { |u| u.unset(:follow_history) } # this will remove the follow_history field
+
 == Usage
 
 To make model followable you need to include Mongo::Followable into your model; You also need to include Mongo::Follower in your follower model:
   class User
     include Mongoid::Document  #for Mongo_Mapper users, this line of code should be include MongoMapper::Document
-    include Mongo::Followable
-    include Mongo::Follower
+    include Mongo::Followable::Followed
+    include Mongo::Followable::Follower
+    include Mongo::Followable::History # you have to add this line to enable follow/followed history
   end
 
   class Group
     include Mongoid::Document  #for Mongo_Mapper users, this line of code should be include MongoMapper::Document
-    include Mongo::Followable
+    include Mongo::Followable::Followed
+    include Mongo::Followable::History # you have to add this line to enable follow/followed history
   end
 
-Now you can set configuration for mongo_followable in environment/*.rb:
-
-    # Note: for current version, you can only set the config once(first time the application is created).
-    #       This should be fixed in next version.
-    config.mongo_followable = { :authorization => false, :history => false } # this is default value
-
-Now you can set authorization:
-    current_user.set_authorization('user', 'game') # now current_user cannot follow User and Game model
-    current_user.unset_authorization('User', 'Game')
+I've decided to remove authorization because it is quite inefficient to keep this field for every record in the database.
+However, it's possible that I'll add it back as a plugin in the future.
 
 And then you can follow and unfollow:
 
@@ -104,6 +108,20 @@ You can also get a model's follow/followed history:
     @user.ever_follow
     @group.ever_followed
 
+or to tell if ever follow/followed by someone:
+
+    @user.ever_follow? @some_group
+    @group.ever_followed? @some_user
+
+Sure you can clear the histories:
+
+    @user.clear_history!
+
+    #or more specific:
+
+    @user.clear_follow_history!
+    @group.clear_followed_history!
+
 Another feature is to get a list of models which has the most followers/followees:
 
     User.with_max_followees
@@ -126,7 +144,7 @@ And see what the common followers/followees are:
     @user.common_followers_with(@group)
     
 * Any bug or issue, please send me an email: ustc.flyingfox@gmail.com
-
+                                                  include Mongo::Followable::History # you have to add this line to enable follow/followed history
 == TODO
 
 * inter-models followable #FINISHED#
@@ -136,6 +154,7 @@ And see what the common followers/followees are:
 * add authorization to followable models #FINISHED#
 * common followers/followees #FINISHED#
 * add support for mongo_mapper in next version #FINISHED#
+* implement plugins: confirmation, authorization etc.
 
 !!If you have any advice, plese do not hesitate to tell me!!
 

data/lib/mongo_followable.rb

@@ -1,10 +1,7 @@
-if defined?(Rails)
-  require File.join(File.dirname(__FILE__), "mongo_followable/railtie")
-end
-
 if defined?(Mongoid) or defined?(MongoMapper)
   require File.join(File.dirname(__FILE__), "mongo_followable/core_ext/string")
-  require File.join(File.dirname(__FILE__), "mongo_followable/followable")
+  require File.join(File.dirname(__FILE__), "mongo_followable/followed")
   require File.join(File.dirname(__FILE__), "mongo_followable/follower")
   require File.join(File.dirname(__FILE__), "../app/models/follow")
+  require File.join(File.dirname(__FILE__), "mongo_followable/features/history")
 end

data/lib/mongo_followable/features/authorization.rb

@@ -0,0 +1,5 @@
+module Mongo
+  module Authorization
+
+  end
+end

data/lib/mongo_followable/features/confirmation.rb

@@ -0,0 +1,5 @@
+module Mongo
+  module Confirmation
+
+  end
+end

data/lib/mongo_followable/features/history.rb

@@ -0,0 +1,76 @@
+module Mongo
+  module Followable
+    module History
+      extend ActiveSupport::Concern
+
+      included do |base|
+        if base.include?(Mongo::Followable::Follower)
+          if defined?(Mongoid)
+            base.field :follow_history, :type => Array, :default => []
+          elsif defined?(MongoMapper)
+            base.key :follow_history, :type => Array, :default => []
+          end
+        end
+
+        if base.include?(Mongo::Followable::Followed)
+          if defined?(Mongoid)
+            base.field :followed_history, :type => Array, :default => []
+          elsif defined?(MongoMapper)
+            base.key :followed_history, :type => Array, :default => []
+          end
+        end
+      end
+
+      module ClassMethods
+ #       def clear_history!
+ #         self.all.each { |m| m.unset(:follow_history) }
+ #         self.all.each { |m| m.unset(:followed_history) }
+ #       end
+      end
+
+      def clear_history!
+        clear_follow_history!
+        clear_followed_histroy!
+      end
+
+      def clear_follow_history!
+        self.update_attribute(:follow_history, []) if has_follow_history?
+      end
+
+      def clear_followed_histroy!
+        self.update_attribute(:followed_history, []) if has_followed_history?
+      end
+
+      def ever_follow
+        rebuild(self.follow_history) if has_follow_history?
+      end
+
+      def ever_followed
+        rebuild(self.followed_history) if has_followed_history?
+      end
+
+      def ever_follow?(model)
+        self.follow_history.include?(model.class.name + "_" + model.id.to_s) if has_follow_history?
+      end
+
+      def ever_followed?(model)
+        self.followed_history.include?(model.class.name + "_" + model.id.to_s) if has_followed_history?
+      end
+
+      private
+        def has_follow_history?
+          self.respond_to? :follow_history
+        end
+
+        def has_followed_history?
+          self.respond_to? :followed_history
+        end
+
+        def rebuild(ary)
+          ary.group_by { |x| x.split("_").first }.
+              inject([]) { |n,(k,v)| n += k.constantize.
+              find(v.map { |x| x.split("_").last}) }
+        end
+    end
+  end
+end

data/lib/mongo_followable/followed.rb

@@ -0,0 +1,193 @@
+module Mongo
+  module Followable
+    module Followed
+      extend ActiveSupport::Concern
+
+      included do |base|
+        if defined?(Mongoid)
+          base.has_many :followers, :class_name => "Follow", :as => :followable, :dependent => :destroy
+        elsif defined?(MongoMapper)
+          base.many :followers, :class_name => "Follow", :as => :followable, :dependent => :destroy
+        end
+      end
+
+      module ClassMethods
+
+        # get certain model's followees of this type
+        #
+        # Example:
+        #   >> @jim = User.new
+        #   >> @ruby = Group.new
+        #   >> @jim.save
+        #   >> @ruby.save
+        #
+        #   >> @jim.follow(@ruby)
+        #   >> User.followees_of(@jim)
+        #   => [@ruby]
+        #
+        #   Arguments:
+        #     model: instance of some followable model
+
+        def followees_of(model)
+          model.followees_by_type(self.name)
+        end
+
+        # 4 methods in this function
+        #
+        # Example:
+        #   >> Group.with_max_followers
+        #   => [@ruby]
+        #   >> Group.with_max_followers_by_type('user')
+        #   => [@ruby]
+
+        ["max", "min"].each do |s|
+          define_method(:"with_#{s}_followers") do
+            follow_array = self.all.to_a.sort! { |a, b| a.followers_count <=> b.followers_count }
+            num = follow_array[-1].followers_count
+            follow_array.select { |c| c.followers_count == num }
+          end
+
+          define_method(:"with_#{s}_followers_by_type") do |*args|
+            follow_array = self.all.to_a.sort! { |a, b| a.followers_count_by_type(args[0]) <=> b.followers_count_by_type(args[0]) }
+            num = follow_array[-1].followers_count_by_type(args[0])
+            follow_array.select { |c| c.followers_count_by_type(args[0]) == num }
+          end
+        end
+
+        #def method_missing(name, *args)
+        #  if name.to_s =~ /^with_(max|min)_followers$/i
+        #    follow_array = self.all.to_a.sort! { |a, b| a.followers_count <=> b.followers_count }
+        #    if $1 == "max"
+        #      max = follow_array[-1].followers_count
+        #      follow_array.select { |c| c.followers_count == max }
+        #    elsif $1 == "min"
+        #      min = follow_array[0].followers_count
+        #      follow_array.select { |c| c.followers_count == min }
+        #    end
+        #  elsif name.to_s =~ /^with_(max|min)_followers_by_type$/i
+        #    follow_array = self.all.to_a.sort! { |a, b| a.followers_count_by_type(args[0]) <=> b.followers_count_by_type(args[0]) }
+        #    if $1 == "max"
+        #      max = follow_array[-1].followers_count_by_type(args[0])
+        #      follow_array.select { |c| c.followers_count_by_type(args[0]) == max }
+        #    elsif $1 == "min"
+        #      min = follow_array[0].followers_count
+        #      follow_array.select { |c| c.followers_count_by_type(args[0]) == min }
+        #    end
+        #  else
+        #    super
+        #  end
+        #end
+
+      end
+
+      # see if this model is followee of some model
+      #
+      # Example:
+      #   >> @ruby.followee_of?(@jim)
+      #   => true
+
+      def followee_of?(model)
+        0 < self.followers.by_model(model).limit(1).count * model.followees.by_model(self).limit(1).count
+      end
+
+      # return true if self is followed by some models
+      #
+      # Example:
+      #   >> @ruby.followed?
+      #   => true
+
+      def followed?
+        0 < self.followers.length
+      end
+
+      # get all the followers of this model, same with classmethod followers_of
+      #
+      # Example:
+      #   >> @ruby.all_followers
+      #   => [@jim]
+
+      def all_followers
+        rebuild_instances(self.followers)
+      end
+
+      def unfollowed(*models, &block)
+        if block_given?
+          models.delete_if { |model| !yield(model) }
+        end
+
+        models.each do |model|
+          unless model == self or !self.followee_of?(model) or !model.follower_of?(self)
+            model.followees.by_model(self).first.destroy
+            self.followers.by_model(model).first.destroy
+          end
+        end
+      end
+
+      # unfollow all
+
+      def unfollowed_all
+        unfollowed(*self.all_followers)
+      end
+
+      # get all the followers of this model in certain type
+      #
+      # Example:
+      #   >> @ruby.followers_by_type("user")
+      #   => [@jim]
+
+      def followers_by_type(type)
+        rebuild_instances(self.followers.by_type(type))
+      end
+
+      # get the number of followers
+      #
+      # Example:
+      #   >> @ruby.followers_count
+      #   => 1
+
+      def followers_count
+        self.followers.count
+      end
+
+      # get the number of followers in certain type
+      #
+      # Example:
+      #   >> @ruby.followers_count_by_type("user")
+      #   => 1
+
+      def followers_count_by_type(type)
+        self.followers.by_type(type).count
+      end
+
+      # return if there is any common followers
+      #
+      # Example:
+      #   >> @ruby.common_followees?(@python)
+      #   => true
+
+      def common_followers?(model)
+        0 < (rebuild_instances(self.followers) & rebuild_instances(model.followers)).length
+      end
+
+      # get common followers with some model
+      #
+      # Example:
+      #   >> @ruby.common_followers_with(@python)
+      #   => [@jim]
+
+      def common_followers_with(model)
+        rebuild_instances(self.followers) & rebuild_instances(model.followers)
+      end
+
+      private
+        def rebuild_instances(follows) #:nodoc:
+          follows.group_by(&:f_type).inject([]) { |r, (k, v)| r += k.constantize.find(v.map(&:f_id)).to_a }
+          #follow_list = []
+          #follows.each do |follow|
+          #  follow_list << follow.f_type.constantize.find(follow.f_id)
+          #end
+          #follow_list
+        end
+    end
+  end
+end

data/lib/mongo_followable/follower.rb

@@ -1,273 +1,216 @@
 module Mongo
-  module Follower
-    extend ActiveSupport::Concern
-
-    included do |base|
-      if defined?(Mongoid)
-        if CONFIG[:authorization]
-          base.field :cannot_follow, :type => Array, :default => []
-        end
-
-        if CONFIG[:history]
-          base.field :follow_history, :type => Array, :default => []
-        end
-
-        base.has_many :followees, :class_name => "Follow", :as => :following, :dependent => :destroy
-      elsif defined?(MongoMapper)
-        if CONFIG[:authorization]
-          base.key :cannot_follow, :type => Array, :default => []
-        end
-
-        if CONFIG[:history]
-          base.key :follow_history, :type => Array, :default => []
-        end
-
-        base.many :followees, :class_name => "Follow", :as => :following, :dependent => :destroy
-      end
+  module Followable
+    module Follower
+     extend ActiveSupport::Concern
+
+     included do |base|
+       if defined?(Mongoid)
+         base.has_many :followees, :class_name => "Follow", :as => :following, :dependent => :destroy
+       elsif defined?(MongoMapper)
+         base.many :followees, :class_name => "Follow", :as => :following, :dependent => :destroy
+       end
+     end
+
+     module ClassMethods
+
+       # get certain model's followers of this type
+       #
+       # Example:
+       #   >> @jim = User.new
+       #   >> @ruby = Group.new
+       #   >> @jim.save
+       #   >> @ruby.save
+       #
+       #   >> @jim.follow(@ruby)
+       #   >> User.followers_of(@ruby)
+       #   => [@jim]
+       #
+       #   Arguments:
+       #     model: instance of some followable model
+
+       def followers_of(model)
+         model.followers_by_type(self.name)
+       end
+
+       # 4 methods in this function
+       #
+       # Example:
+       #   >> User.with_max_followees
+       #   => [@jim]
+       #   >> User.with_max_followees_by_type('group')
+       #   => [@jim]
+
+       ["max", "min"].each do |s|
+         define_method(:"with_#{s}_followees") do
+           follow_array = self.all.to_a.sort! { |a, b| a.followees_count <=> b.followees_count }
+           num = follow_array[-1].followees_count
+           follow_array.select { |c| c.followees_count == num }
+         end
+
+         define_method(:"with_#{s}_followees_by_type") do |*args|
+           follow_array = self.all.to_a.sort! { |a, b| a.followees_count_by_type(args[0]) <=> b.followees_count_by_type(args[0]) }
+           num = follow_array[-1].followees_count_by_type(args[0])
+           follow_array.select { |c| c.followees_count_by_type(args[0]) == num }
+         end
+       end
+
+       #def method_missing(name, *args)
+       #  if name.to_s =~ /^with_(max|min)_followees$/i
+       #    follow_array = self.all.to_a.sort! { |a, b| a.followees_count <=> b.followees_count }
+       #    if $1 == "max"
+       #      max = follow_array[-1].followees_count
+       #      follow_array.select { |c| c.followees_count == max }
+       #    elsif $1 == "min"
+       #      min = follow_array[0].followees_count
+       #      follow_array.select { |c| c.followees_count == min }
+       #    end
+       #  elsif name.to_s =~ /^with_(max|min)_followees_by_type$/i
+       #    follow_array = self.all.to_a.sort! { |a, b| a.followees_count_by_type(args[0]) <=> b.followees_count_by_type(args[0]) }
+       #    if $1 == "max"
+       #      max = follow_array[-1].followees_count_by_type(args[0])
+       #      follow_array.select { |c| c.followees_count_by_type(args[0]) == max }
+       #    elsif $1 == "min"
+       #      min = follow_array[0].followees_count
+       #      follow_array.select { |c| c.followees_count_by_type(args[0]) == min }
+       #    end
+       #  else
+       #    super
+       #  end
+       #end
+
+     end
+
+     # see if this model is follower of some model
+     #
+     # Example:
+     #   >> @jim.follower_of?(@ruby)
+     #   => true
+
+     def follower_of?(model)
+       0 < self.followees.by_model(model).limit(1).count * model.followers.by_model(self).limit(1).count
+     end
+
+     # return true if self is following some models
+     #
+     # Example:
+     #   >> @jim.following?
+     #   => true
+
+     def following?
+       0 < self.followees.length
+     end
+
+     # get all the followees of this model, same with classmethod followees_of
+     #
+     # Example:
+     #   >> @jim.all_followees
+     #   => [@ruby]
+
+     def all_followees
+       rebuild_instances(self.followees)
+     end
+
+     # get all the followees of this model in certain type
+     #
+     # Example:
+     #   >> @ruby.followees_by_type("group")
+     #   => [@ruby]
+
+     def followees_by_type(type)
+       rebuild_instances(self.followees.by_type(type))
+     end
+
+     # follow some model
+
+     def follow(*models, &block)
+       if block_given?
+         models.delete_if { |model| !yield(model) }
+       end
+
+       models.each do |model|
+         unless model == self or self.follower_of?(model) or model.followee_of?(self)
+           model.followers.create!(:f_type => self.class.name, :f_id => self.id.to_s)
+           self.followees.create!(:f_type => model.class.name, :f_id => model.id.to_s)
+
+           model.followed_history << self.class.name + '_' + self.id.to_s if model.respond_to? :followed_history
+           self.follow_history << model.class.name + '_' + model.id.to_s if self.respond_to? :follow_history
+
+           model.save
+           self.save
+         end
+       end
+     end
+
+     # unfollow some model
+
+     def unfollow(*models, &block)
+       if block_given?
+         models.delete_if { |model| !yield(model) }
+       end
+
+       models.each do |model|
+         unless model == self or !self.follower_of?(model) or !model.followee_of?(self)
+           model.followers.by_model(self).first.destroy
+           self.followees.by_model(model).first.destroy
+         end
+       end
+     end
+
+     # unfollow all
+
+     def unfollow_all
+       unfollow(*self.all_followees)
+     end
+
+     # get the number of followees
+     #
+     # Example:
+     #   >> @jim.followers_count
+     #   => 1
+
+     def followees_count
+       self.followees.count
+     end
+
+     # get the number of followers in certain type
+     #
+     # Example:
+     #   >> @ruby.followers_count_by_type("user")
+     #   => 1
+
+     def followees_count_by_type(type)
+       self.followees.by_type(type).count
+     end
+
+     # return if there is any common followees
+     #
+     # Example:
+     #   >> @jim.common_followees?(@tom)
+     #   => true
+
+     def common_followees?(model)
+       0 < (rebuild_instances(self.followees) & rebuild_instances(model.followees)).length
+     end
+
+     # get common followees with some model
+     #
+     # Example:
+     #   >> @jim.common_followees_with(@tom)
+     #   => [@ruby]
+
+     def common_followees_with(model)
+       rebuild_instances(self.followees) & rebuild_instances(model.followees)
+     end
+
+     private
+       def rebuild_instances(follows) #:nodoc:
+         follows.group_by(&:f_type).inject([]) { |r, (k, v)| r += k.constantize.find(v.map(&:f_id)).to_a }
+         #follow_list = []
+         #follows.each do |follow|
+         #  follow_list << follow.f_type.constantize.find(follow.f_id)
+         #end
+         #follow_list
+       end
     end
-
-    module ClassMethods
-
-      # get certain model's followers of this type
-      #
-      # Example:
-      #   >> @jim = User.new
-      #   >> @ruby = Group.new
-      #   >> @jim.save
-      #   >> @ruby.save
-      #
-      #   >> @jim.follow(@ruby)
-      #   >> User.followers_of(@ruby)
-      #   => [@jim]
-      #
-      #   Arguments:
-      #     model: instance of some followable model
-
-      def followers_of(model)
-        model.followers_by_type(self.name)
-      end
-
-      # 4 methods in this function
-      #
-      # Example:
-      #   >> User.with_max_followees
-      #   => [@jim]
-      #   >> User.with_max_followees_by_type('group')
-      #   => [@jim]
-
-      ["max", "min"].each do |s|
-        define_method(:"with_#{s}_followees") do
-          follow_array = self.all.to_a.sort! { |a, b| a.followees_count <=> b.followees_count }
-          num = follow_array[-1].followees_count
-          follow_array.select { |c| c.followees_count == num }
-        end
-
-        define_method(:"with_#{s}_followees_by_type") do |*args|
-          follow_array = self.all.to_a.sort! { |a, b| a.followees_count_by_type(args[0]) <=> b.followees_count_by_type(args[0]) }
-          num = follow_array[-1].followees_count_by_type(args[0])
-          follow_array.select { |c| c.followees_count_by_type(args[0]) == num }
-        end
-      end
-
-      #def method_missing(name, *args)
-      #  if name.to_s =~ /^with_(max|min)_followees$/i
-      #    follow_array = self.all.to_a.sort! { |a, b| a.followees_count <=> b.followees_count }
-      #    if $1 == "max"
-      #      max = follow_array[-1].followees_count
-      #      follow_array.select { |c| c.followees_count == max }
-      #    elsif $1 == "min"
-      #      min = follow_array[0].followees_count
-      #      follow_array.select { |c| c.followees_count == min }
-      #    end
-      #  elsif name.to_s =~ /^with_(max|min)_followees_by_type$/i
-      #    follow_array = self.all.to_a.sort! { |a, b| a.followees_count_by_type(args[0]) <=> b.followees_count_by_type(args[0]) }
-      #    if $1 == "max"
-      #      max = follow_array[-1].followees_count_by_type(args[0])
-      #      follow_array.select { |c| c.followees_count_by_type(args[0]) == max }
-      #    elsif $1 == "min"
-      #      min = follow_array[0].followees_count
-      #      follow_array.select { |c| c.followees_count_by_type(args[0]) == min }
-      #    end
-      #  else
-      #    super
-      #  end
-      #end
-
-    end
-
-    # set which mongoid user cannot follow
-    #
-    # Example:
-    #   >> @jim.set_authorization('group', 'user')
-    #   => true
-
-    if CONFIG[:authorization]
-      define_method(:set_authorization) do |*models|
-        models.each do |model|
-          self.cannot_follow << model.safe_capitalize
-        end
-        self.save
-      end
-
-      #unset which mongoid user cannot follow
-
-      define_method(:unset_authorization) do |*models|
-        models.each do |model|
-          self.cannot_follow -= [model.safe_capitalize]
-        end
-        self.save
-      end
-    end
-
-    # see if this model is follower of some model
-    #
-    # Example:
-    #   >> @jim.follower_of?(@ruby)
-    #   => true
-
-    def follower_of?(model)
-      0 < self.followees.by_model(model).limit(1).count * model.followers.by_model(self).limit(1).count
-    end
-
-    # return true if self is following some models
-    #
-    # Example:
-    #   >> @jim.following?
-    #   => true
-
-    def following?
-      0 < self.followees.length
-    end
-
-    # get all the followees of this model, same with classmethod followees_of
-    #
-    # Example:
-    #   >> @jim.all_followees
-    #   => [@ruby]
-
-    def all_followees
-      rebuild_instances(self.followees)
-    end
-
-    # get all the followees of this model in certain type
-    #
-    # Example:
-    #   >> @ruby.followees_by_type("group")
-    #   => [@ruby]
-
-    def followees_by_type(type)
-      rebuild_instances(self.followees.by_type(type))
-    end
-
-    # follow some model
-
-    def follow(*models, &block)
-      if block_given?
-        models.delete_if { |model| !yield(model) }
-      end
-
-      models.each do |model|
-        term = CONFIG[:authorization] ? (self.cannot_follow.include?(model.class.name) or model.cannot_followed.include?(self.class.name)) : false
-
-        unless model == self or self.follower_of?(model) or model.followee_of?(self) or term
-          model.followers.create!(:f_type => self.class.name, :f_id => self.id.to_s)
-          self.followees.create!(:f_type => model.class.name, :f_id => model.id.to_s)
-
-          if CONFIG[:history]
-            model.followed_history << self.class.name + '_' + self.id.to_s
-            self.follow_history << model.class.name + '_' + model.id.to_s
-          end
-
-          model.save
-          self.save
-        end
-      end
-    end
-
-    # unfollow some model
-
-    def unfollow(*models, &block)
-      if block_given?
-        models.delete_if { |model| !yield(model) }
-      end
-
-      models.each do |model|
-        unless model == self or !self.follower_of?(model) or !model.followee_of?(self) or self.cannot_follow.include?(model.class.name) or model.cannot_followed.include?(self.class.name)
-          model.followers.by_model(self).first.destroy
-          self.followees.by_model(model).first.destroy
-        end
-      end
-    end
-
-    # unfollow all
-
-    def unfollow_all
-      unfollow(*self.all_followees)
-    end
-
-    # get the number of followees
-    #
-    # Example:
-    #   >> @jim.followers_count
-    #   => 1
-
-    def followees_count
-      self.followees.count
-    end
-
-    # get the number of followers in certain type
-    #
-    # Example:
-    #   >> @ruby.followers_count_by_type("user")
-    #   => 1
-
-    def followees_count_by_type(type)
-      self.followees.by_type(type).count
-    end
-
-    # see user's follow history
-    #
-    # Example:
-    #   >> @jim.ever_follow
-    #   => [@ruby]
-
-    if CONFIG[:history]
-      define_method(:ever_follow) do
-        follow = []
-        self.follow_history.each do |h|
-          follow << h.split('_')[0].constantize.find(h.split('_')[1])
-        end
-        follow
-      end
-    end
-
-    # return if there is any common followees
-    #
-    # Example:
-    #   >> @jim.common_followees?(@tom)
-    #   => true
-
-    def common_followees?(model)
-      0 < (rebuild_instances(self.followees) & rebuild_instances(model.followees)).length
-    end
-
-    # get common followees with some model
-    #
-    # Example:
-    #   >> @jim.common_followees_with(@tom)
-    #   => [@ruby]
-
-    def common_followees_with(model)
-      rebuild_instances(self.followees) & rebuild_instances(model.followees)
-    end
-
-    private
-      def rebuild_instances(follows)
-        follow_list = []
-        follows.each do |follow|
-          follow_list << follow.f_type.constantize.find(follow.f_id)
-        end
-        follow_list
-      end
   end
 end