recommendable 0.1.5 → 0.1.6

data/app/models/recommendable/stashed_item.rb

@@ -1,8 +1,9 @@
 module Recommendable
   class StashedItem < ActiveRecord::Base
     self.table_name = 'recommendable_stashed_items'
+    attr_accessible :user_id, :stashable_id, :stashable_type
 
-    belongs_to :user, :class_name => Recommendable.user_class.to_s
+    belongs_to :user, :class_name => Recommendable.user_class.to_s, :foreign_key => :user_id
     belongs_to :stashable, :polymorphic => :true
     
     validates :user_id, :uniqueness => { :scope => [:stashable_id, :stashable_type],

data/app/workers/recommendable/recommendation_refresher.rb

@@ -3,10 +3,9 @@ module Recommendable
     include Resque::Plugins::UniqueJob
     @queue = :recommendable
     
-    def self.perform(user_id, other_ids)
+    def self.perform(user_id)
       user = Recommendable.user_class.find(user_id)
-      return if other_ids.empty?
-      user.send :update_similarities, other_ids
+      user.send :update_similarities
       user.send :update_recommendations
     end
   end

data/lib/generators/recommendable/templates/initializer.rb

@@ -10,6 +10,12 @@ require "resque-loner"
 # Connect to Redis via a UNIX socket instead
 <% unless options.redis_socket %># <% end %>Recommendable.redis = Redis.new(:sock => "<%= options.redis_socket %>")
 
+# Resque also needs a connection to Redis. If you are currently initializing
+# Resque somewhere else, leave this commented out. Otherwise, let it use the
+# same Redis connection as Recommendable. If redis is running on localhost:6379,
+# You can leave this commented out.
+# Resque.redis = Recommendable.redis
+
 # Tell Redis which database to use (usually between 0 and 15). The default of 0
 # is most likely okay unless you have another application using that database.
 # Recommendable.redis.select "0"

data/lib/recommendable/acts_as_recommendable.rb

@@ -9,17 +9,18 @@ module Recommendable
           
           has_many :likes, :as => :likeable, :dependent => :destroy, :class_name => "Recommendable::Like"
           has_many :dislikes, :as => :dislikeable, :dependent => :destroy, :class_name => "Recommendable::Dislike"
-          has_many :liked_by, :through => :likes, :source => :user
-          has_many :disliked_by, :through => :dislikes, :source => :user
           has_many :ignores, :as => :ignoreable, :dependent => :destroy, :class_name => "Recommendable::Ignore"
           has_many :stashes, :as => :stashable, :dependent => :destroy, :class_name => "Recommendable::StashedItem"
+          has_many :liked_by, :through => :likes, :source => :user, :foreign_key => :user_id
+          has_many :disliked_by, :through => :dislikes, :source => :user, :foreign_key => :user_id
           
           include LikeableMethods
           include DislikeableMethods
+
+          before_destroy :remove_from_scores
           
           def self.acts_as_recommendable?() true end
 
-
           def been_rated?
             likes.count + dislikes.count > 0
           end
@@ -30,7 +31,34 @@ module Recommendable
             liked_by + disliked_by
           end
 
+          def self.top(count=1)
+            ids = Recommendable.redis.zrevrange(self.score_set, 0, count - 1).map(&:to_i)
+
+            items = self.find(ids)
+
+            return items.sort do |x, y|
+              ids.index(x.id) <=> ids.index(y.id)
+            end
+          end
+
           private
+
+          def update_score
+            return 0 unless been_rated?
+
+            z = 1.96
+            n = likes.count + dislikes.count
+
+            phat = 1.0 * likes.count / n.to_f
+            score = (phat + z*z/(2*n) - z * Math.sqrt((phat*(1-phat)+z*z/(4*n))/n))/(1+z*z/n)
+
+            Recommendable.redis.zadd self.class.score_set, score, self.id
+          end
+
+          def remove_from_scores
+            Recommendable.redis.zrem self.class.score_set, self.id
+            true
+          end
           
           # Used for setup purposes. Calls convenience methods to create sets
           # in redis of users that both like and dislike this object.
@@ -55,6 +83,10 @@ module Recommendable
             likes.map(&:user_id) + dislikes.map(&:user_id)
           end
 
+          def self.score_set
+            "#{self}:sorted"
+          end
+
           private :likes, :dislikes, :ignores, :stashes
         end
       end
@@ -77,8 +109,8 @@ module Recommendable
       # @private
       # @return [String] the key in Redis pointing to the set
       def create_liked_by_set
-        set = "#{self.class}:#{id}:liked_by"
-        liked_by.each {|rater| Recommendable.redis.sadd set, rater.id}
+        set = "#{redis_key}:liked_by"
+        liked_by.each { |rater| Recommendable.redis.sadd set, rater.id }
         return set
       end
     end
@@ -91,8 +123,8 @@ module Recommendable
       # @private
       # @return [String] the key in Redis pointing to the set
       def create_disliked_by_set
-        set = "#{self.class}:#{id}:disliked_by"
-        disliked_by.each {|rater| Recommendable.redis.sadd set, rater.id}
+        set = "#{redis_key}:disliked_by"
+        disliked_by.each { |rater| Recommendable.redis.sadd set, rater.id }
         return set
       end
     end

data/lib/recommendable/acts_as_recommended_to.rb

@@ -14,10 +14,10 @@ module Recommendable
         class_eval do
           Recommendable.user_class = self
           
-          has_many :likes, :class_name => "Recommendable::Like", :dependent => :destroy
-          has_many :dislikes, :class_name => "Recommendable::Dislike", :dependent => :destroy
-          has_many :ignores, :class_name => "Recommendable::Ignore", :dependent => :destroy
-          has_many :stashed_items, :class_name => "Recommendable::StashedItem", :dependent => :destroy
+          has_many :likes, :class_name => "Recommendable::Like", :dependent => :destroy, :foreign_key => :user_id
+          has_many :dislikes, :class_name => "Recommendable::Dislike", :dependent => :destroy, :foreign_key => :user_id
+          has_many :ignores, :class_name => "Recommendable::Ignore", :dependent => :destroy, :foreign_key => :user_id
+          has_many :stashed_items, :class_name => "Recommendable::StashedItem", :dependent => :destroy, :foreign_key => :user_id
           
           include LikeMethods
           include DislikeMethods
@@ -25,6 +25,35 @@ module Recommendable
           include IgnoreMethods
           include RecommendationMethods
 
+          before_destroy :remove_from_similarities
+          before_destroy :remove_recommendations
+
+          def method_missing(method, *args, &block)
+            if method.to_s =~ /(liked|disliked|ignored|stashed|recommended)_(.+)/
+              begin
+                super unless $2.classify.constantize.acts_as_recommendable?
+
+                self.send "#{$1}_for", $2.classify.constantize
+              rescue NameError
+                super
+              end
+            else
+              super
+            end
+          end
+
+          def respond_to?(method)
+            if method.to_s =~ /(liked|disliked|ignored|stashed|recommended)_(.+)/
+              begin
+                $2.classify.constantize.acts_as_recommendable?
+              rescue NameError
+                false
+              end
+            else
+              super
+            end
+          end
+
           private :likes, :dislikes, :ignores, :stashed_items
         end
       end
@@ -41,10 +70,11 @@ module Recommendable
       # @raise [RecordNotRecommendableError] if you have not declared the passed object's model to `act_as_recommendable`
       def like(object)
         raise RecordNotRecommendableError unless object.recommendable?
-        return if likes?(object)
-        completely_unrecommend(object)
-        likes.create!(:likeable_id => object.id, :likeable_type => object.class.to_s)
-        Resque.enqueue RecommendationRefresher, self.id, object.send(:rates_by)
+        return if likes? object
+        completely_unrecommend object
+        likes.create! :likeable_id => object.id, :likeable_type => object.class.to_s
+        object.send :update_score
+        Resque.enqueue RecommendationRefresher, self.id
         true
       end
       
@@ -53,7 +83,7 @@ module Recommendable
       # @param [Object] object the object you want to check
       # @return true if self likes object, false if not
       def likes?(object)
-        likes.exists?(:likeable_id => object.id, :likeable_type => object.class.to_s)
+        likes.exists? :likeable_id => object.id, :likeable_type => object.class.to_s
       end
       
       # Destroys a Recommendable::Like currently associating self with object
@@ -62,7 +92,8 @@ module Recommendable
       # @return true if object is unliked, nil if nothing happened
       def unlike(object)
         if likes.where(:likeable_id => object.id, :likeable_type => object.class.to_s).first.try(:destroy)
-          Resque.enqueue RecommendationRefresher, self.id, object.send(:rates_by)
+          object.send :update_score
+          Resque.enqueue RecommendationRefresher, self.id
           true
         end
       end
@@ -71,20 +102,20 @@ module Recommendable
       
       # @return [Array] an array of ActiveRecord objects that self has liked
       def liked
-        likes.map {|like| like.likeable}
+        Recommendable.recommendable_classes.flat_map { |klass| liked_for klass }
       end
 
+      private
+
       # Get a list of records belonging to a passed class that self currently
       # likes.
       #
       # @param [Class, String, Symbol] klass the class of records. Can be the class constant, or a String/Symbol representation of the class name.
       # @return [Array] an array of ActiveRecord objects that self has liked belonging to klass
       def liked_for(klass)
-        klass.to_s.classify.constantize.find likes_for(klass).map(&:likeable_id)
+        likes.where(:likeable_type => klass).includes(:likeable).map(&:likeable)
       end
 
-      private
-
       # Get a list of Recommendable::Likes with a `#likeable_type` of the passed
       # class.
       #
@@ -92,7 +123,7 @@ module Recommendable
       # @note You should not need to use this method. (see {#liked_for})
       # @private
       def likes_for(klass)
-        likes.where(:likeable_type => klass.to_s.classify)
+        likes.where :likeable_type => klass.to_s.classify
       end
     end
     
@@ -107,10 +138,11 @@ module Recommendable
       # @raise [RecordNotRecommendableError] if you have not declared the passed object's model to `act_as_recommendable`
       def dislike(object)
         raise RecordNotRecommendableError unless object.recommendable?
-        return if dislikes?(object)
-        completely_unrecommend(object)
-        dislikes.create!(:dislikeable_id => object.id, :dislikeable_type => object.class.to_s)
-        Resque.enqueue RecommendationRefresher, self.id, object.send(:rates_by)
+        return if dislikes? object
+        completely_unrecommend object
+        dislikes.create! :dislikeable_id => object.id, :dislikeable_type => object.class.to_s
+        object.send :update_score
+        Resque.enqueue RecommendationRefresher, self.id
         true
       end
       
@@ -128,7 +160,8 @@ module Recommendable
       # @return true if object is removed from self's dislikes, nil if nothing happened
       def undislike(object)
         if dislikes.where(:dislikeable_id => object.id, :dislikeable_type => object.class.to_s).first.try(:destroy)
-          Resque.enqueue RecommendationRefresher, self.id, object.send(:rates_by)
+          object.send :update_score
+          Resque.enqueue RecommendationRefresher, self.id
           true
         end
       end
@@ -137,19 +170,19 @@ module Recommendable
       
       # @return [Array] an array of ActiveRecord objects that self has disliked
       def disliked
-        dislikes.map {|dislike| dislike.dislikeable}
+        Recommendable.recommendable_classes.flat_map { |klass| disliked_for(klass) }
       end
 
+      private
+
       # Get a list of records belonging to a passed class that self currently
       # dislikes.
       #
       # @param [Class, String, Symbol] klass the class of records. Can be the class constant, or a String/Symbol representation of the class name.
       # @return [Array] an array of ActiveRecord objects that self has disliked belonging to klass
       def disliked_for(klass)
-        klass.to_s.classify.constantize.find dislikes_for(klass).map(&:dislikeable_id)
+        dislikes.where(:dislikeable_type => klass).includes(:dislikeable).map(&:dislikeable)
       end
-
-      private
       
       # Get a list of Recommendable::Dislikes with a `#dislikeable_type` of the
       # passed class.
@@ -158,7 +191,7 @@ module Recommendable
       # @note You should not need to use this method. (see {#disliked_for})
       # @private
       def dislikes_for(klass)
-        dislikes.where(:dislikeable_type => klass.to_s.classify)
+        dislikes.where :dislikeable_type => klass.to_s.classify
       end
     end
 
@@ -174,9 +207,9 @@ module Recommendable
       def stash(object)
         raise RecordNotRecommendableError unless object.recommendable?
         return if rated?(object) || stashed?(object)
-        unignore(object)
-        unpredict(object)
-        stashed_items.create!(:stashable_id => object.id, :stashable_type => object.class.to_s)
+        unignore object
+        unpredict object
+        stashed_items.create! :stashable_id => object.id, :stashable_type => object.class.to_s
         true
       end
       
@@ -185,7 +218,7 @@ module Recommendable
       # @param [Object] object the object you want to check
       # @return true if self has stashed object, false if not
       def stashed?(object)
-        stashed_items.exists?(:stashable_id => object.id, :stashable_type => object.class.to_s)
+        stashed_items.exists? :stashable_id => object.id, :stashable_type => object.class.to_s
       end
       
       # Destroys a Recommendable::StashedItem currently associating self with object
@@ -200,28 +233,18 @@ module Recommendable
       #
       # @return [Array] an array of ActiveRecord objects that self has stashed
       def stashed
-        stashed_items.map {|item| item.stashable}
+        Recommendable.recommendable_classes.flat_map { |klass| stashed_for klass }
       end
 
+      private
+
       # Get a list of records belonging to a passed class that self currently
       # has stashed away for later.
       #
       # @param [Class, String, Symbol] klass the class of records. Can be the class constant, or a String/Symbol representation of the class name.
       # @return [Array] an array of ActiveRecord objects that self has stashed belonging to klass
       def stashed_for(klass)
-        klass.to_s.classify.constantize.find stash_for(klass).map(&:stashable_id)
-      end
-
-      private
-
-      # Get a list of Recommendable::StashedItems with a stashable_type of the
-      # passed class.
-      #
-      # @param [Class, String, Symbol] klass the class for which you would like to return self's stashed items. Can be the class constant, or a String/Symbol representation of the class name.
-      # @note You should not need to use this method. (see {#stashed_for})
-      # @private
-      def stash_for(klass)
-        stashed_items.where(:stashable_type => klass.to_s.classify)
+        stashed_items.where(:stashable_type => klass).includes(:stashable).map(&:stashable)
       end
     end
     
@@ -236,9 +259,9 @@ module Recommendable
       # @raise [RecordNotRecommendableError] if you have not declared the passed object's model to `act_as_recommendable`
       def ignore(object)
         raise RecordNotRecommendableError unless object.recommendable?
-        return if ignored?(object)
-        completely_unrecommend(object)
-        ignores.create!(:ignoreable_id => object.id, :ignoreable_type => object.class.to_s)
+        return if ignored? object
+        completely_unrecommend object
+        ignores.create! :ignoreable_id => object.id, :ignoreable_type => object.class.to_s
         true
       end
       
@@ -247,7 +270,7 @@ module Recommendable
       # @param [Object] object the object you want to check
       # @return true if self has ignored object, false if not
       def ignored?(object)
-        ignores.exists?(:ignoreable_id => object.id, :ignoreable_type => object.class.to_s)
+        ignores.exists? :ignoreable_id => object.id, :ignoreable_type => object.class.to_s
       end
       
       # Destroys a Recommendable::Ignore currently associating self with object
@@ -262,28 +285,18 @@ module Recommendable
       
       # @return [Array] an array of ActiveRecord objects that self has ignored
       def ignored
-        ignores.map {|ignore| ignore.ignoreable}
+        Recommendable.recommendable_classes.flat_map { |klass| ignored_for klass }
       end
 
+      private
+
       # Get a list of records belonging to a passed class that self is 
       # currently ignoring.
       #
       # @param [Class, String, Symbol] klass the class of records. Can be the class constant, or a String/Symbol representation of the class name.
       # @return [Array] an array of ActiveRecord objects that self has ignored belonging to klass
       def ignored_for(klass)
-        klass.to_s.classify.constantize.find ignores_for(klass).map(&:ignoreable_id)
-      end
-
-      private
-      
-      # Get a list of Recommendable::Ignores with a `#ignoreable_type` of the
-      # passed class.
-      #
-      # @param [Class, String, Symbol] klass the class for which you would like to return self's ignores. Can be the class constant, or a String/Symbol representation of the class name.
-      # @note You should not need to use this method. (see {#ignored_for})
-      # @private
-      def ignores_for(klass)
-        ignores.where(:ignoreable_type => klass.to_s.classify)
+        ignores.where(:ignoreable_type => klass).includes(:ignoreable).map(&:ignoreable)
       end
     end
     
@@ -312,10 +325,10 @@ module Recommendable
       # @return [Array] An array of instances of your user class
       def similar_raters(options = {})
         defaults = { :count => 10 }
-        options = defaults.merge(options)
+        options = defaults.merge options
         
         rater_ids = Recommendable.redis.zrevrange(similarity_set, 0, options[:count] - 1).map(&:to_i)
-        raters = Recommendable.user_class.where("ID IN (?)", rater_ids)
+        raters = Recommendable.user_class.find rater_ids
         
         # The query loses the ordering, so...
         return raters.sort do |x, y|
@@ -331,14 +344,12 @@ module Recommendable
       # @option options [Fixnum] :count (10) the number of recommendations to get
       # @return [Array] an array of ActiveRecord objects that are recommendable
       def recommendations(options = {})
-        defaults = { :count => 10 }
-        options = defaults.merge options
         return [] if likes.count + dislikes.count == 0
 
         unioned_predictions = "#{self.class}:#{id}:predictions"
-        Recommendable.redis.zunionstore unioned_predictions, Recommendable.recommendable_classes.map {|klass| predictions_set_for(klass)}
+        Recommendable.redis.zunionstore unioned_predictions, Recommendable.recommendable_classes.map { |klass| predictions_set_for(klass) }
         
-        recommendations = Recommendable.redis.zrevrange(unioned_predictions, 0, options[:count]).map do |object|
+        recommendations = Recommendable.redis.zrevrange(unioned_predictions, 0, 10).map do |object|
           klass, id = object.split(":")
           klass.constantize.find(id)
         end
@@ -346,23 +357,18 @@ module Recommendable
         Recommendable.redis.del(unioned_predictions) and return recommendations
       end
       
-      # Get a list of recommendations for self on a single recommendable type.
+      # Get a list of 10 recommendations for self on a single recommendable type.
       # Recommendations are returned in a descending order with the first index
       # being the object that self has been found most likely to enjoy.
       #
       # @param [Class, String, Symbol] klass the class to receive recommendations for. Can be the class constant, or a String/Symbol representation of the class name.
-      # @param [Hash] options the options for returning this list
-      # @option options [Fixnum] :count (10) the number of recommendations to get
       # @return [Array] an array of ActiveRecord objects that are recommendable
-      def recommendations_for(klass, options = {})
-        defaults = { :count => 10 }
-        options = defaults.merge options
-        
+      def recommended_for(klass)
         return [] if likes_for(klass).count + dislikes_for(klass).count == 0 || Recommendable.redis.zcard(predictions_set_for(klass)) == 0
       
         recommendations = []
         i = 0
-        until recommendations.size == options[:count]
+        until recommendations.size == 10
           prediction = Recommendable.redis.zrevrange(predictions_set_for(klass), i, i).first
           return recommendations unless prediction # User might not have enough recommendations to return
           
@@ -399,7 +405,7 @@ module Recommendable
       # @param [Hash] options the options for this intersection
       # @option options [Class, String, Symbol] :class ('nil') Restrict the intersection to a single recommendable type. By default, all recomendable types are considered
       # @option options [true, false] :return_records (true) Return the actual Model instances
-      # @return [Array] An array of IDs, or strings from Redis in the form of "#{likeable_type}:#{id}" if options[:class] is set
+      # @return [Array] Typically, an array of ActiveRecord objects (unless :return_records is false)
       def common_likes_with(rater, options = {})
         defaults = { :class => nil,
                      :return_records => true }
@@ -432,7 +438,7 @@ module Recommendable
       # @param [Hash] options the options for this intersection
       # @option options [Class, String, Symbol] :class ('nil') Restrict the intersection to a single recommendable type. By default, all recomendable types are considered
       # @option options [true, false] :return_records (true) Return the actual Model instances
-      # @return [Array] An array of IDs, or strings from Redis in the form of #{dislikeable_type}:#{id}" if options[:class] is set
+      # @return [Array] Typically, an array of ActiveRecord objects (unless :return_records is false)
       def common_dislikes_with(rater, options = {})
         defaults = { :class => nil,
                      :return_records => true }
@@ -467,7 +473,7 @@ module Recommendable
       # @param [Hash] options the options for this intersection
       # @option options [Class, String, Symbol] :class ('nil') Restrict the intersections to a single recommendable type. By default, all recomendable types are considered
       # @option options [true, false] :return_records (true) Return the actual Model instances
-      # @return [Array] An array of IDs, or strings from Redis in the form of #{recommendable_type}:#{id}" if options[:class] is set
+      # @return [Array] Typically, an array of ActiveRecord objects (unless :return_records is false)
       def disagreements_with(rater, options = {})
         defaults = { :class => nil,
                      :return_records => true }
@@ -620,18 +626,35 @@ module Recommendable
       # other users. This is called in the Resque job to refresh recommendations.
       #
       # @private
-      def update_similarities(rater_ids = nil)
+      def update_similarities
         return unless rated_anything?
         create_recommended_to_sets
-        rater_ids ||= Recommendable.user_class.select(:id).map!(&:id)
         
-        Recommendable.user_class.find(rater_ids).each do |rater|
-          next if self == rater
+        Recommendable.user_class.find_each do |rater|
+          next if self == rater || !rater.rated_anything?
           Recommendable.redis.zadd similarity_set, similarity_with(rater), rater.id
         end
         
         destroy_recommended_to_sets
       end
+
+      def remove_from_similarities
+        Recommendable.redis.del similarity_set
+
+        Recommendable.user_class.find_each do |user|
+          Recommendable.redis.zrem user.send(:similarity_set), self.id
+        end
+
+        true
+      end
+
+      def remove_recommendations
+        Recommendable.recommendable_classes.each do |klass|
+          Recommendable.redis.del predictions_set_for(klass)
+        end
+
+        true
+      end
       
       # @private
       def unpredict(object)