recommendable 0.1.3 → 0.1.4

data/CHANGELOG.markdown

@@ -1,8 +1,26 @@
 Changelog
 =========
 
-0.1.2 (current version)
+0.1.4 (current version)
 -----------------------
+* `acts_as_recommendable` is no longer needed in your models
+* Instead of declaring `acts_as_recommended_to` in your User class, please use `recommends` instead, passing in a list of your recommendable models as a list of symbols (e.g. `recommends :movies, :books`)
+* Your initializer should no longer declare the user class. This is no longer necessary and is deprecated.
+* Fix an issue that caused the unnecessary need for eager loading models in development
+* Removed aliases: `liked_records`, `liked_records_for`, `disliked_records`, and `disliked_records_for`
+* Renamed methods:
+  * `has_ignored?` => `ignored?`
+  * `has_stashed?` => `stashed?`
+* Code quality tweaks
+
+0.1.3 (current version)
+-----------------------
+
+* Improvements to speed of similarity calculations.
+* Added an instance method to items that act_as_recommendable, `rated_by`. This returns an array of users that like or dislike the item.
+
+0.1.2
+-----
 
 * Fix an issue that could cause similarity values between users to be incorrect.
 * `User#common_likes_with` and `User#common_dislikes_with` now return the actual Model instances by default. Accordingly, these methods are no longer private.

data/README.markdown

@@ -1,8 +1,8 @@
 # recommendable [![Build Status](https://secure.travis-ci.org/davidcelis/recommendable.png)](http://travis-ci.org/davidcelis/recommendable)
 
 Recommendable is a Rails Engine to add Like/Dislike functionality to your 
-application. It uses Redis to generate recommendations quickly through a
-collaborative filtering algorithm that I modified myself. Your users' tastes
+application. It uses Redis to generate recommendations quickly through [a
+collaborative filtering algorithm that I modified myself][6]. Your users' tastes
 are compared with one another and used to give them great recommendations!
 Yes, Redis is required. Scroll to the end of the README for more info on that.
 
@@ -30,7 +30,7 @@ Add the following to your Rails application's `Gemfile`:
 After your `bundle install`, you can then run:
 
 ``` bash
-$ rails g recommendable:install (--user-class=User)
+$ rails g recommendable:install
 ```
 
 After running the installation generator, you should double check
@@ -59,29 +59,13 @@ In your Rails model that represents your application's user:
 
 ``` ruby
 class User < ActiveRecord::Base
-  acts_as_recommended_to
+  recommends :movies, :shows, :other_things
   
   # ...
 end
 ```
 
-Then, from any Rails model you wish your `user` to be able to `like` or `dislike`:
-
-``` ruby
-class Movie < ActiveRecord::Base
-  acts_as_recommendable
-  
-  # ...
-end
-
-class Show < ActiveRecord::Base
-  acts_as_recommendable
-  
-  # ...
-end
-````
-
-And that's it!
+Just pass in a list of classes and that's it!
 
 ### Liking/Disliking
 
@@ -122,7 +106,7 @@ wish to return a set of liked or disliked objects for only one of those
 models.
 
 ``` ruby
-current_user.liked_for(Movie)
+current_user.liked_for(Movie) # or "movie", or :movie
 #=> [#<Movie name: '2001: A Space Odyssey', year: 1968>, #<Movie name: 'Back to the Future', :year => 1985>]
 current_user.disliked_for(Show)
 #=> []
@@ -163,7 +147,7 @@ current_user.like(movie_to_watch_later)
 #=> true
 current_user.stash(movie_to_watch_later)
 #=> nil
-current_user.has_stashed?(movie_to_watch_later)
+current_user.stashed?(movie_to_watch_later)
 #=> false
 ```
 
@@ -344,3 +328,4 @@ further details.
 [3]: http://wiki.github.com/defunkt/resque/contributing
 [4]: http://help.github.com/forking/
 [5]: http://help.github.com/pull-requests/
+[6]: http://davidcelis.com/blog/2012/02/07/collaborative-filtering-with-likes-and-dislikes/

data/lib/generators/recommendable/USAGE

@@ -2,7 +2,7 @@ Description:
     This generator will install Recommendable's initializer.rb file and migrate the Like and Dislike tables into your database unless specified.
 
 Example:
-    rails generate recommendable:install --user-class=YourUserClass
+    rails generate recommendable:install
 
     This will create:
         config/initializers/recommendable.rb

data/lib/generators/recommendable/install_generator.rb

@@ -3,7 +3,6 @@ require 'rails/generators'
 module Recommendable
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      argument     :user_model,   :type => :string,  :default => "User",            :desc => "Your user model that will be liking and disliking objects."
       argument     :redis_host,   :type => :string,  :default => "localhost",       :desc => "The hostname your redis server is running on."
       argument     :redis_port,   :type => :string,  :default => "6379",            :desc => "The port your redis server is running on."
       class_option :redis_socket, :type => :string,                                 :desc => "Indicates the UNIX socket your redis server is running on (if it is)."
@@ -36,12 +35,6 @@ module Recommendable
       def finished
         puts "Done! Recommendable has been successfully installed. Please configure it in config/intializers/recommendable.rb"
       end
-      
-      private
-      
-      def user_class
-        user_model.camelize
-      end
     end
   end
-end
+end

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

@@ -2,9 +2,6 @@ require "redis"
 require "resque"
 require "resque-loner"
 
-# What class will be liking/disliking objects and receiving recommendations?
-Recommendable.user_class = "<%= user_class %>"
-
 # Recommendable requires a connection to a running redis-server. Either create
 # a new instance based on a host/port or UNIX socket, or pass in an existing
 # Redis client instance.
@@ -15,4 +12,4 @@ Recommendable.user_class = "<%= user_class %>"
 
 # 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"
+Recommendable.redis.select "0"

data/lib/recommendable/acts_as_recommendable.rb

@@ -17,9 +17,10 @@ module Recommendable
           include LikeableMethods
           include DislikeableMethods
           
-          def self.acts_as_recommendable? ; true ; end
+          def self.acts_as_recommendable?() true end
 
-          def has_been_rated?
+
+          def been_rated?
             likes.count + dislikes.count > 0
           end
 
@@ -28,13 +29,8 @@ module Recommendable
           def rated_by
             liked_by + disliked_by
           end
-          
-          # Returns an array of IDs of users that have liked or disliked this item.
-          # @return [Array] an array of user IDs
-          # @private
-          def rates_by
-            likes.map(&:user_id) + dislikes.map(&:user_id)
-          end
+
+          private
           
           # Used for setup purposes. Calls convenience methods to create sets
           # in redis of users that both like and dislike this object.
@@ -52,22 +48,30 @@ module Recommendable
             Recommendable.redis.del "#{self.class}:#{id}:disliked_by"
           end
 
-          private :likes, :dislikes, :ignores, :stashes, :rates_by,
-                  :create_recommendable_sets, :destroy_recommendable_sets
+          # Returns an array of IDs of users that have liked or disliked this item.
+          # @return [Array] an array of user IDs
+          # @private
+          def rates_by
+            likes.map(&:user_id) + dislikes.map(&:user_id)
+          end
+
+          private :likes, :dislikes, :ignores, :stashes
         end
       end
 
-      def acts_as_recommendable? ; false ; end
+      def acts_as_recommendable?() false end
     end
 
     # Instance methods.
-    def recommendable? ; self.class.acts_as_recommendable? ; end
+    def recommendable?() self.class.acts_as_recommendable? end
 
-    def redis_key ; "#{self.class}:#{id}" ; end
+    def redis_key() "#{self.class}:#{id}" end
 
     protected :redis_key
     
     module LikeableMethods
+      private
+
       # Used for setup purposes. Creates a set in redis containing users that
       # have liked this object.
       # @private
@@ -77,11 +81,11 @@ module Recommendable
         liked_by.each {|rater| Recommendable.redis.sadd set, rater.id}
         return set
       end
-
-      private :create_liked_by_set
     end
     
     module DislikeableMethods
+      private
+
       # Used for setup purposes. Creates a set in redis containing users that
       # have disliked this object.
       # @private
@@ -91,8 +95,6 @@ module Recommendable
         disliked_by.each {|rater| Recommendable.redis.sadd set, rater.id}
         return set
       end
-
-      private :create_disliked_by_set
     end
   end
 end

data/lib/recommendable/acts_as_recommended_to.rb

@@ -5,8 +5,15 @@ module Recommendable
     extend ActiveSupport::Concern
     
     module ClassMethods
+      def recommends(*things)
+        acts_as_recommended_to
+        things.each { |thing| thing.to_s.classify.constantize.acts_as_recommendable }
+      end
+
       def acts_as_recommended_to
         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
@@ -18,18 +25,11 @@ module Recommendable
           include IgnoreMethods
           include RecommendationMethods
 
-          def self.acts_as_recommended_to? ; true ; end
-
           private :likes, :dislikes, :ignores, :stashed_items
         end
       end
-
-      def acts_as_recommended_to? ; false ; end
     end
 
-    # Instance method.
-    def can_rate? ; self.class.acts_as_recommended_to? ; end
-
     module LikeMethods
       # Creates a Recommendable::Like to associate self to a passed object. If
       # self is currently found to have disliked object, the corresponding
@@ -74,29 +74,26 @@ module Recommendable
         likes.map {|like| like.likeable}
       end
 
-      alias_method :liked_records, :liked
-      
-      # Get a list of Recommendable::Likes with a `#likeable_type` of the passed
-      # class.
-      #
-      # @param [Class, String, Symbol] klass the class for which you would like to return self's likes. Can be the class constant, or a String/Symbol representation of the class name.
-      # @note You should not need to use this method. (see {#liked_for})
-      # @private
-      def likes_for(klass)
-        likes.where(:likeable_type => klassify(klass).to_s)
-      end
-      
       # 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)
-        klassify(klass).find likes_for(klass).map(&:likeable_id)
+        klass.to_s.classify.constantize.find likes_for(klass).map(&:likeable_id)
       end
 
-      alias_method :liked_records_for, :liked_for
-      private :likes_for
+      private
+
+      # Get a list of Recommendable::Likes with a `#likeable_type` of the passed
+      # class.
+      #
+      # @param [Class, String, Symbol] klass the class for which you would like to return self's likes. Can be the class constant, or a String/Symbol representation of the class name.
+      # @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)
+      end
     end
     
     module DislikeMethods
@@ -143,7 +140,16 @@ module Recommendable
         dislikes.map {|dislike| dislike.dislikeable}
       end
 
-      alias_method :disliked_records, :disliked
+      # 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)
+      end
+
+      private
       
       # Get a list of Recommendable::Dislikes with a `#dislikeable_type` of the
       # passed class.
@@ -152,20 +158,8 @@ module Recommendable
       # @note You should not need to use this method. (see {#disliked_for})
       # @private
       def dislikes_for(klass)
-        dislikes.where(:dislikeable_type => klassify(klass).to_s)
-      end
-      
-      # 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)
-        klassify(klass).find dislikes_for(klass).map(&:dislikeable_id)
+        dislikes.where(:dislikeable_type => klass.to_s.classify)
       end
-
-      alias_method :disliked_records_for, :disliked_for
-      private :dislikes_for
     end
 
     module StashMethods
@@ -179,7 +173,7 @@ module Recommendable
       # @raise [RecordNotRecommendableError] if you have not declared the passed object's model to `act_as_recommendable`
       def stash(object)
         raise RecordNotRecommendableError unless object.recommendable?
-        return if has_rated?(object) || has_stashed?(object)
+        return if rated?(object) || stashed?(object)
         unignore(object)
         unpredict(object)
         stashed_items.create!(:stashable_id => object.id, :stashable_type => object.class.to_s)
@@ -190,7 +184,7 @@ module Recommendable
       # 
       # @param [Object] object the object you want to check
       # @return true if self has stashed object, false if not
-      def has_stashed?(object)
+      def stashed?(object)
         stashed_items.exists?(:stashable_id => object.id, :stashable_type => object.class.to_s)
       end
       
@@ -203,35 +197,32 @@ module Recommendable
       end
       
       # Get a list of records that self has currently stashed for later
-      
+      #
       # @return [Array] an array of ActiveRecord objects that self has stashed
       def stashed
         stashed_items.map {|item| item.stashable}
       end
 
-      alias_method :stashed_records, :stashed
-      
-      # 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 => klassify(klass).to_s)
-      end
-      
       # 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)
-        klassify(klass).find stash_for(klass).map(&:stashable_id)
+        klass.to_s.classify.constantize.find stash_for(klass).map(&:stashable_id)
       end
 
-      alias_method :stashed_records_for, :stashed_for
-      private :stash_for
+      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)
+      end
     end
     
     module IgnoreMethods
@@ -245,7 +236,7 @@ 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 has_ignored?(object)
+        return if ignored?(object)
         completely_unrecommend(object)
         ignores.create!(:ignoreable_id => object.id, :ignoreable_type => object.class.to_s)
         true
@@ -255,7 +246,7 @@ module Recommendable
       # 
       # @param [Object] object the object you want to check
       # @return true if self has ignored object, false if not
-      def has_ignored?(object)
+      def ignored?(object)
         ignores.exists?(:ignoreable_id => object.id, :ignoreable_type => object.class.to_s)
       end
       
@@ -274,7 +265,16 @@ module Recommendable
         ignores.map {|ignore| ignore.ignoreable}
       end
 
-      alias_method :ignored_records, :ignored
+      # 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.
@@ -283,20 +283,8 @@ module Recommendable
       # @note You should not need to use this method. (see {#ignored_for})
       # @private
       def ignores_for(klass)
-        ignores.where(:ignoreable_type => klassify(klass).to_s)
+        ignores.where(:ignoreable_type => klass.to_s.classify)
       end
-      
-      # 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)
-        klassify(klass).find ignores_for(klass).map(&:ignoreable_id)
-      end
-
-      alias_method :ignored_records_for, :ignored_for
-      private :ignores_for
     end
     
     module RecommendationMethods
@@ -304,14 +292,14 @@ module Recommendable
       # 
       # @param [Object] object the object you want to check
       # @return true if self has liked or disliked object, false if not
-      def has_rated?(object)
+      def rated?(object)
         likes?(object) || dislikes?(object)
       end
       
       # Checks to see if self has liked or disliked any objects yet.
       # 
       # @return true if self has liked or disliked anything, false if not
-      def has_rated_anything?
+      def rated_anything?
         likes.count > 0 || dislikes.count > 0
       end
       
@@ -378,7 +366,7 @@ module Recommendable
           prediction = Recommendable.redis.zrevrange(predictions_set_for(klass), i, i).first
           return recommendations unless prediction # User might not have enough recommendations to return
           
-          object = klassify(klass).find(prediction.split(":")[1])
+          object = klass.to_s.classify.constantize.find(prediction.split(":")[1])
           recommendations << object
           i += 1
         end
@@ -404,28 +392,6 @@ module Recommendable
         -probability_of_liking(object)
       end
       
-      # Checks how similar a passed rater is with self. This method calculates
-      # a numeric similarity value that can fall between -1.0 and 1.0. A value of
-      # 1.0 indicates that rater has the exact same likes and dislikes as self
-      # while a value of -1.0 indicates that rater dislikes every object that self
-      # likes and likes every object that self dislikes. A value of 0.0 would
-      # indicate that the two users share no likes or dislikes.
-      #
-      # @param [Object] rater an ActiveRecord object declared to `act_as_recommendable_to`
-      # @return [Float] the numeric similarity between self and rater
-      # @note The returned value relies on which user the method is called on. current_user.similarity_with(rater) will not equal rater.similarity_with(current_user) unless their sets of likes and dislikes are identical. current_user.similarity_with(rater) will return 1.0 even if rater has several likes/dislikes that `current_user` does not.
-      # @private
-      def similarity_with(rater)
-        rater.create_recommended_to_sets
-        agreements = common_likes_with(rater, :return_records => false).size
-        agreements += common_dislikes_with(rater, :return_records => false).size
-        disagreements = disagreements_with(rater, :return_records => false).size
-        
-        similarity = (agreements - disagreements).to_f / (likes.count + dislikes.count)
-        rater.destroy_recommended_to_sets
-        
-        return similarity
-      end
       # Makes a call to Redis and intersects the sets of likes belonging to self
       # and rater.
       #
@@ -441,15 +407,15 @@ module Recommendable
         
         if options[:class]
           in_common = Recommendable.redis.sinter likes_set_for(options[:class]), rater.likes_set_for(options[:class])
-          klassify(options[:class]).find in_common if options[:return_records]
+          options[:class].to_s.classify.constantize.find in_common if options[:return_records]
         else
           Recommendable.recommendable_classes.flat_map do |klass|
             in_common = Recommendable.redis.sinter(likes_set_for(klass), rater.likes_set_for(klass))
 
             if options[:return_records]
-              klassify(klass).find in_common
+              klass.to_s.classify.constantize.find in_common
             else
-              in_common.map {|id| "#{klassify(klass)}:#{id}"}
+              in_common.map {|id| "#{klass.to_s.classify}:#{id}"}
             end
           end
         end
@@ -470,15 +436,15 @@ module Recommendable
         
         if options[:class]
           in_common = Recommendable.redis.sinter dislikes_set_for(options[:class]), rater.dislikes_set_for(options[:class])
-          klassify(options[:class]).find in_common if options[:return_records]
+          options[:class].to_s.classify.constantize.find in_common if options[:return_records]
         else
           Recommendable.recommendable_classes.flat_map do |klass|
             in_common = Recommendable.redis.sinter(dislikes_set_for(klass), rater.dislikes_set_for(klass))
 
             if options[:return_records]
-              klassify(klass).find in_common
+              klass.to_s.classify.constantize.find in_common
             else
-              in_common.map {|id| "#{klassify(klass)}:#{id}"}
+              in_common.map {|id| "#{klass.to_s.classify}:#{id}"}
             end
           end
         end
@@ -502,21 +468,116 @@ module Recommendable
         if options[:class]
           disagreements =  Recommendable.redis.sinter(likes_set_for(options[:class]), rater.likes_set_for(options[:class]))
           disagreements += Recommendable.redis.sinter(dislikes_set_for(options[:class]), rater.dislikes_set_for(options[:class]))
-          klassify(options[:class]).find disagreements if options[:return_records]
+          options[:class].to_s.classify.constantize.find disagreements if options[:return_records]
         else
           Recommendable.recommendable_classes.flat_map do |klass|
             disagreements = Recommendable.redis.sinter(likes_set_for(klass), rater.likes_set_for(klass))
             disagreements += Recommendable.redis.sinter(dislikes_set_for(klass), rater.dislikes_set_for(klass))
 
             if options[:return_records]
-              klassify(klass).find disagreements
+              klass.to_s.classify.constantize.find disagreements
             else
-              disagreements.map {|id| "#{klassify(klass)}:#{id}"}
+              disagreements.map {|id| "#{klass.to_s.classify}:#{id}"}
             end
           end
         end
       end
+
+      # Used internally during liking/disliking/stashing/ignoring objects. This
+      # will prep an object to be liked, disliked, etc. by making sure that self
+      # doesn't already have this item in their list of likes, dislikes, stashed
+      # items or ignored items.
+      #
+      # param [Object] object the object to destroy Recommendable models for
+      # @private
+      def completely_unrecommend(object)
+        unlike(object)
+        undislike(object)
+        unstash(object)
+        unignore(object)
+        unpredict(object)
+      end
+
+      protected
+
+      # @private
+      def likes_set_for(klass)
+        "#{self.class}:#{id}:likes:#{klass}"
+      end
       
+      # @private
+      def dislikes_set_for(klass)
+        "#{self.class}:#{id}:dislikes:#{klass}"
+      end
+
+      # Used for setup purposes. Creates and populates sets in redis containing
+      # self's likes and dislikes.
+      # @private
+      def create_recommended_to_sets
+        Recommendable.recommendable_classes.each do |klass|
+          likes_for(klass).each {|like| Recommendable.redis.sadd likes_set_for(klass), like.likeable_id }
+          dislikes_for(klass).each {|dislike| Recommendable.redis.sadd dislikes_set_for(klass), dislike.dislikeable_id }
+        end
+      end
+      
+      # Used for teardown purposes. Destroys the redis sets containing self's
+      # likes and dislikes, as they are only used during the process of
+      # updating recommendations and similarity values.
+      # @private
+      def destroy_recommended_to_sets
+        Recommendable.recommendable_classes.each do |klass|
+          Recommendable.redis.del likes_set_for(klass)
+          Recommendable.redis.del dislikes_set_for(klass)
+        end
+      end
+
+      private
+
+      # Checks how similar a passed rater is with self. This method calculates
+      # a numeric similarity value that can fall between -1.0 and 1.0. A value of
+      # 1.0 indicates that rater has the exact same likes and dislikes as self
+      # while a value of -1.0 indicates that rater dislikes every object that self
+      # likes and likes every object that self dislikes. A value of 0.0 would
+      # indicate that the two users share no likes or dislikes.
+      #
+      # @param [Object] rater an ActiveRecord object declared to `act_as_recommendable_to`
+      # @return [Float] the numeric similarity between self and rater
+      # @note The returned value relies on which user the method is called on. current_user.similarity_with(rater) will not equal rater.similarity_with(current_user) unless their sets of likes and dislikes are identical. current_user.similarity_with(rater) will return 1.0 even if rater has several likes/dislikes that `current_user` does not.
+      # @private
+      def similarity_with(rater)
+        rater.create_recommended_to_sets
+        agreements = common_likes_with(rater, :return_records => false).size
+        agreements += common_dislikes_with(rater, :return_records => false).size
+        disagreements = disagreements_with(rater, :return_records => false).size
+        
+        similarity = (agreements - disagreements).to_f / (likes.count + dislikes.count)
+        rater.destroy_recommended_to_sets
+        
+        return similarity
+      end
+
+      # Used internally to update self's prediction values across all
+      # recommendable types. This is called in the Resque job to refresh
+      # recommendations.
+      #
+      # @private
+      def update_recommendations
+        Recommendable.recommendable_classes.each {|klass| update_recommendations_for klass}
+      end
+      
+      # Used internally to update self's prediction values across a single
+      # recommendable type. Convenience method for {#update_recommendations}
+      #
+      # @param [Class] klass the recommendable type to update predictions for
+      # @private
+      def update_recommendations_for(klass)
+        klass.find_each do |object|
+          next if rated?(object) || !object.been_rated? || ignored?(object) || stashed?(object)
+          prediction = predict(object)
+          Recommendable.redis.zadd(predictions_set_for(object.class), prediction, object.redis_key) if prediction
+        end
+      end
+
       # Predict how likely it is that self will like a passed in object. This
       # probability is not based on percentage. 0.0 indicates that self will
       # neither like nor dislike the passed object. Values that approach Infinity
@@ -548,52 +609,23 @@ module Recommendable
       #
       # @private
       def update_similarities(rater_ids = nil)
-        return unless has_rated_anything?
+        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 || !rater.can_rate?
+          next if self == rater
           Recommendable.redis.zadd similarity_set, similarity_with(rater), rater.id
         end
         
         destroy_recommended_to_sets
       end
       
-      # Used internally to update self's prediction values across all
-      # recommendable types. This is called in the Resque job to refresh
-      # recommendations.
-      #
-      # @private
-      def update_recommendations
-        Recommendable.recommendable_classes.each do |klass|
-          update_recommendations_for(klass)
-        end
-      end
-      
-      # Used internally to update self's prediction values across a single
-      # recommendable type. Convenience method for {#update_recommendations}
-      #
-      # @param [Class] klass the recommendable type to update predictions for
       # @private
-      def update_recommendations_for(klass)
-        klass.find_each do |object|
-          next if has_rated?(object) || !object.has_been_rated? || has_ignored?(object) || has_stashed?(object)
-          prediction = predict(object)
-          Recommendable.redis.zadd(predictions_set_for(object.class), prediction, object.redis_key) if prediction
-        end
+      def unpredict(object)
+        Recommendable.redis.zrem predictions_set_for(object.class), object.redis_key
       end
 
-      # @private
-      def likes_set_for(klass)
-        "#{self.class}:#{id}:likes:#{klass}"
-      end
-      
-      # @private
-      def dislikes_set_for(klass)
-        "#{self.class}:#{id}:dislikes:#{klass}"
-      end
-      
       # @private
       def similarity_set
         "#{self.class}:#{id}:similarities"
@@ -603,58 +635,6 @@ module Recommendable
       def predictions_set_for(klass)
         "#{self.class}:#{id}:predictions:#{klass}"
       end
-      
-      # @private
-      def unpredict(object)
-        Recommendable.redis.zrem predictions_set_for(object.class), object.redis_key
-      end
-      
-      # Used for setup purposes. Creates and populates sets in redis containing
-      # self's likes and dislikes.
-      # @private
-      def create_recommended_to_sets
-        Recommendable.recommendable_classes.each do |klass|
-          likes_for(klass).each {|like| Recommendable.redis.sadd likes_set_for(klass), like.likeable_id }
-          dislikes_for(klass).each {|dislike| Recommendable.redis.sadd dislikes_set_for(klass), dislike.dislikeable_id }
-        end
-      end
-      
-      # Used for teardown purposes. Destroys the redis sets containing self's
-      # likes and dislikes, as they are only used during the process of
-      # updating recommendations and similarity values.
-      # @private
-      def destroy_recommended_to_sets
-        Recommendable.recommendable_classes.each do |klass|
-          Recommendable.redis.del likes_set_for(klass)
-          Recommendable.redis.del dislikes_set_for(klass)
-        end
-      end
-
-      # Used internally during liking/disliking/stashing/ignoring objects. This
-      # will prep an object to be liked, disliked, etc. by making sure that self
-      # doesn't already have this item in their list of likes, dislikes, stashed
-      # items or ignored items.
-      #
-      # param [Object] object the object to destroy Recommendable models for
-      # @private
-      def completely_unrecommend(object)
-        unlike(object)
-        undislike(object)
-        unstash(object)
-        unignore(object)
-        unpredict(object)
-      end
-
-      protected :likes_set_for, :dislikes_set_for, :create_recommended_to_sets,
-                :destroy_recommended_to_sets
-
-      private :similarity_set, :unpredict, :predictions_set_for,
-              :update_recommendations_for, :update_recommendations,
-              :update_similarities, :similarity_with, :predict
     end
   end
 end
-
-def klassify(klass)
-  (klass.is_a?(String) || klass.is_a?(Symbol)) ? klass.to_s.camelize.constantize : klass
-end

data/lib/recommendable/railtie.rb

@@ -2,14 +2,5 @@ module Recommendable
   class Railtie < Rails::Railtie
     ActiveRecord::Base.send :include, Recommendable::ActsAsRecommendedTo
     ActiveRecord::Base.send :include, Recommendable::ActsAsRecommendable
-
-    # Force load models if in a non-development environment and not caching classes
-    config.after_initialize do |app|
-      force_load_models if !Rails.env.development? && !app.config.cache_classes
-    end
-
-    def self.force_load_models
-      Dir["#{ Rails.root }/app/models/**/*.rb"].each { |m| load m }
-    end
   end
 end

data/lib/recommendable/version.rb

@@ -1,3 +1,3 @@
 module Recommendable
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/recommendable.rb

@@ -7,11 +7,7 @@ require 'recommendable/version'
 
 module Recommendable
   mattr_accessor :redis, :user_class
-  mattr_writer :user_class, :recommendable_classes
-  
-  def self.user_class
-    @@user_class.camelize.constantize
-  end
+  mattr_writer :recommendable_classes
   
   def self.recommendable_classes
     @@recommendable_classes ||= []

data/spec/models/user_spec.rb

@@ -64,14 +64,14 @@ class UserSpec < MiniTest::Spec
       it "should not be ignoring an item after liking it" do
         @user.ignore(@movie)
         @user.like(@movie).must_equal true
-        @user.has_ignored?(@movie).must_equal false
+        @user.ignored?(@movie).must_equal false
         @user.likes?(@movie).must_equal true
       end
 
       it "should not have an item stashed after liking it" do
         @user.stash(@movie)
         @user.like(@movie).must_equal true
-        @user.has_stashed?(@movie).must_equal false
+        @user.stashed?(@movie).must_equal false
         @user.likes?(@movie).must_equal true
       end
 
@@ -97,14 +97,14 @@ class UserSpec < MiniTest::Spec
       it "should not be ignoring an item after disliking it" do
         @user.ignore(@movie)
         @user.dislike(@movie).must_equal true
-        @user.has_ignored?(@movie).must_equal false
+        @user.ignored?(@movie).must_equal false
         @user.dislikes?(@movie).must_equal true
       end
 
       it "should not have an item stashed after disliking it" do
         @user.stash(@movie)
         @user.dislike(@movie).must_equal true
-        @user.has_stashed?(@movie).must_equal false
+        @user.stashed?(@movie).must_equal false
         @user.dislikes?(@movie).must_equal true
       end
 
@@ -116,21 +116,21 @@ class UserSpec < MiniTest::Spec
         @user.like(@movie)
         @user.ignore(@movie).must_equal true
         @user.likes?(@movie).must_equal false
-        @user.has_ignored?(@movie).must_equal true
+        @user.ignored?(@movie).must_equal true
       end
 
       it "should not dislike an item after ignoring it" do
         @user.dislike(@movie)
         @user.ignore(@movie).must_equal true
         @user.dislikes?(@movie).must_equal false
-        @user.has_ignored?(@movie).must_equal true
+        @user.ignored?(@movie).must_equal true
       end
 
       it "should not have an item stashed after ignoring it" do
         @user.stash(@movie)
         @user.ignore(@movie).must_equal true
-        @user.has_stashed?(@movie).must_equal false
-        @user.has_ignored?(@movie).must_equal true
+        @user.stashed?(@movie).must_equal false
+        @user.ignored?(@movie).must_equal true
       end
 
       it "should be able to stash a recommendable item" do
@@ -141,21 +141,21 @@ class UserSpec < MiniTest::Spec
         @user.like(@movie)
         @user.stash(@movie).must_be_nil
         @user.likes?(@movie).must_equal true
-        @user.has_stashed?(@movie).must_equal false
+        @user.stashed?(@movie).must_equal false
       end
 
       it "should not stash a disliked item" do
         @user.dislike(@movie)
         @user.stash(@movie).must_be_nil
         @user.dislikes?(@movie).must_equal true
-        @user.has_stashed?(@movie).must_equal false
+        @user.stashed?(@movie).must_equal false
       end
 
       it "should not have an item ignored after stashing it" do
         @user.ignore(@movie)
         @user.stash(@movie).must_equal true
-        @user.has_ignored?(@movie).must_equal false
-        @user.has_stashed?(@movie).must_equal true
+        @user.ignored?(@movie).must_equal false
+        @user.stashed?(@movie).must_equal true
       end
       
       it "should not be able to rate or ignore an item that is not recommendable. doing so should not be enough to create Redis keys" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recommendable
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70109049948340 !ruby/object:Gem::Requirement
+  requirement: &70238356296840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70109049948340
+  version_requirements: *70238356296840
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70109049964200 !ruby/object:Gem::Requirement
+  requirement: &70238356312480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70109049964200
+  version_requirements: *70238356312480
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &70109049963440 !ruby/object:Gem::Requirement
+  requirement: &70238356311720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70109049963440
+  version_requirements: *70238356311720
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70109049962620 !ruby/object:Gem::Requirement
+  requirement: &70238356310980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *70109049962620
+  version_requirements: *70238356310980
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70109049961560 !ruby/object:Gem::Requirement
+  requirement: &70238356310160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *70109049961560
+  version_requirements: *70238356310160
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70109049959600 !ruby/object:Gem::Requirement
+  requirement: &70238356309340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,10 +76,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *70109049959600
+  version_requirements: *70238356309340
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &70109049958960 !ruby/object:Gem::Requirement
+  requirement: &70238356308780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70109049958960
+  version_requirements: *70238356308780
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70109049957640 !ruby/object:Gem::Requirement
+  requirement: &70238356307740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70109049957640
+  version_requirements: *70238356307740
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70109049971980 !ruby/object:Gem::Requirement
+  requirement: &70238356307200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -109,10 +109,10 @@ dependencies:
         version: 2.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70109049971980
+  version_requirements: *70238356307200
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &70109049971120 !ruby/object:Gem::Requirement
+  requirement: &70238356306660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -120,10 +120,10 @@ dependencies:
         version: 1.19.0
   type: :runtime
   prerelease: false
-  version_requirements: *70109049971120
+  version_requirements: *70238356306660
 - !ruby/object:Gem::Dependency
   name: resque-loner
-  requirement: &70109049969980 !ruby/object:Gem::Requirement
+  requirement: &70238356305800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -131,7 +131,7 @@ dependencies:
         version: 1.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70109049969980
+  version_requirements: *70238356305800
 description: Allow a model (typically User) to Like and/or Dislike models in your
   app. Generate recommendations quickly using redis.
 email: david@davidcelis.com