recommendable 0.2.1.1 → 1.0.0

data/CHANGELOG.markdown

@@ -1,8 +1,27 @@
 Changelog
 =========
 
-0.2.0 (current version)
------------------------
+1.0.0 (current version)
+---------------------
+* Dynamic finders now return ActiveRecord::Relations! This means you can chain other ActiveRecord query methods like so:
+
+```ruby
+current_user.recommended_posts.where(:category => "technology")
+current_user.liked_movies.limit(10)
+current_user.stashed_books.where(:author => "Cormac McCarthy")
+current_user.disliked_shows.joins(:cast_members).where('cast_members.name = Kim Kardashian')
+```
+
+* You can now specify a count for `User#recommendations`:
+
+```ruby
+current_user.recommendations(10)
+```
+
+* Bug fixes
+
+0.2.0
+-----
 * NOTE: This release is NOT backwards compatible. Please migrate your databases:
 
 ```

data/Gemfile

@@ -1,17 +1,17 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 # Add dependencies required to use your gem here.
-gem "rails",        ">= 3.1.0"
-gem "redis",        "~> 2.2.0"
-gem "resque",       "~> 1.19.0"
-gem "resque-loner", "~> 1.2.0"
+gem 'rails',        '>= 3.1.0'
+gem 'redis',        '>= 2.2.0'
+gem 'resque',       '~> 1.19.0'
+gem 'resque-loner', '~> 1.2.0'
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "sqlite3"
-  gem "minitest"
-  gem "shoulda"
-  gem "miniskirt"
-  gem "yard",    "~> 0.6.0"
-  gem "bundler", ">= 1.0.0"
+  gem 'sqlite3'
+  gem 'minitest'
+  gem 'shoulda'
+  gem 'miniskirt'
+  gem 'yard',    '~> 0.6.0'
+  gem 'bundler', '>= 1.0.0'
 end

data/Gemfile.lock

@@ -110,7 +110,7 @@ DEPENDENCIES
   miniskirt
   minitest
   rails (>= 3.1.0)
-  redis (~> 2.2.0)
+  redis (>= 2.2.0)
   resque (~> 1.19.0)
   resque-loner (~> 1.2.0)
   shoulda

data/README.markdown

@@ -2,6 +2,11 @@
 
 Recommendable is an engine for Rails 3 applications to quickly add the ability for your users to Like/Dislike items and receive recommendations for new items. It uses Redis to store your recommendations and keep them sorted by how good the recommendation is.
 
+Requirements
+------------
+* Ruby 1.9.2 (1.9.x if using from git. May run on 1.8.7, I don't know)
+* Rails 3.x
+
 Installation
 ------------
 

data/app/models/recommendable/ignore.rb

@@ -8,6 +8,7 @@ module Recommendable
     
     validates :user_id, :uniqueness => { :scope => [:ignorable_id, :ignorable_type],
                                          :message => "has already ignored this item" }
+    
     def ignorable_type=(sType)
       super sType.to_s.classify.constantize.base_class.to_s
     end

data/app/models/recommendable/stash.rb

@@ -8,6 +8,7 @@ module Recommendable
     
     validates :user_id, :uniqueness => { :scope => [:stashable_id, :stashable_type],
                                          :message => "has already stashed this item" }
+    
     def stashable_type=(sType)
       super sType.to_s.classify.constantize.base_class.to_s
     end

data/lib/recommendable/acts_as_recommendable.rb

@@ -24,7 +24,7 @@ module Recommendable
           include LikeableMethods
           include DislikeableMethods
 
-          before_destroy :remove_from_scores
+          before_destroy :remove_from_scores, :remove_from_recommendations
           
           def self.acts_as_recommendable?() true end
 
@@ -42,10 +42,9 @@ module Recommendable
             ids = Recommendable.redis.zrevrange(self.score_set, 0, count - 1).map(&:to_i)
 
             items = self.find ids
+            return items.first if count == 1
 
-            return items.sort do |x, y|
-              ids.index(x.id) <=> ids.index(y.id)
-            end
+            return items.sort { |x, y| ids.index(x.id) <=> ids.index(y.id) }
           end
 
           private
@@ -66,6 +65,12 @@ module Recommendable
             Recommendable.redis.zrem self.class.score_set, self.id
             true
           end
+
+          def remove_from_recommendations
+            Recommendable.user_class.find_each do |user|
+              user.send :completely_unrecommend, self
+            end
+          end
           
           # Used for setup purposes. Calls convenience methods to create sets
           # in redis of users that both like and dislike this object.
@@ -100,7 +105,9 @@ module Recommendable
 
       def acts_as_recommendable?() false end
 
-      def sti?() self.base_class != self end
+      def sti?
+        self.base_class != self && self.base_class.table_name == self.table_name
+      end
 
       private
     end

data/lib/recommendable/acts_as_recommended_to.rb

@@ -19,15 +19,14 @@ module Recommendable
           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::Stash", :dependent => :destroy, :foreign_key => :user_id
-          
+
           include LikeMethods
           include DislikeMethods
           include StashMethods
           include IgnoreMethods
           include RecommendationMethods
 
-          before_destroy :remove_from_similarities
-          before_destroy :remove_recommendations
+          before_destroy :remove_from_similarities, :remove_recommendations
 
           def method_missing method, *args, &block
             if method.to_s =~ /^(liked|disliked)_(.+)_in_common_with$/
@@ -42,7 +41,7 @@ module Recommendable
               begin
                 super unless $2.classify.constantize.acts_as_recommendable?
 
-                self.send "#{$1}_for", $2.classify.constantize
+                self.send "#{$1}_for", $2.classify.constantize, *args
               rescue NameError
                 super
               end
@@ -52,8 +51,7 @@ module Recommendable
           end
 
           def respond_to? method, include_private = false
-            if method.to_s =~ /^(liked|disliked|ignored|stashed|recommended)_(.+)$/ || \
-               method.to_s =~ /^common_(liked|disliked)_(.+)_with$/
+            if method.to_s =~ /^(liked|disliked|ignored|stashed|recommended)_(.+)$/ || method.to_s =~ /^common_(liked|disliked)_(.+)_with$/
               begin
                 $2.classify.constantize.acts_as_recommendable?
               rescue NameError
@@ -112,7 +110,7 @@ module Recommendable
       
       # @return [Array] an array of ActiveRecord objects that self has liked
       def liked
-        Recommendable.recommendable_classes.flat_map { |klass| liked_for klass }
+        Recommendable.recommendable_classes.map { |klass| liked_for klass }.flatten
       end
 
       private
@@ -121,15 +119,15 @@ module Recommendable
       # 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
+      # @return [ActiveRecord::Relation] an ActiveRecord::Relation of records that self has liked
       def liked_for klass
-        liked = if klass.sti?
-          likes.joins manual_join(klass, 'like')
+        ids = if klass.sti?
+          likes.joins(manual_join(klass, 'like')).map(&:likeable_id)
         else
-          likes.where(:likeable_type => klass.to_s).includes(:likeable)
+          likes.where(:likeable_type => klass.to_s).map(&:likeable_id)
         end
 
-        liked.map(&:likeable)
+        klass.where('ID IN (?)', ids)
       end
 
       # Get a list of Recommendable::Likes with a `#likeable_type` of the passed
@@ -190,7 +188,7 @@ module Recommendable
       
       # @return [Array] an array of ActiveRecord objects that self has disliked
       def disliked
-        Recommendable.recommendable_classes.flat_map { |klass| disliked_for klass }
+        Recommendable.recommendable_classes.map { |klass| disliked_for klass }.flatten
       end
 
       private
@@ -199,15 +197,15 @@ module Recommendable
       # 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
+      # @return [ActiveRecord::Relation] an ActiveRecord::Relation of records that self has disliked
       def disliked_for klass
-        disliked = if klass.sti?
-          dislikes.joins manual_join(klass, 'dislike')
+        ids = if klass.sti?
+          dislikes.joins(manual_join(klass, 'dislike')).map(&:dislikeable_id)
         else
-          dislikes.where(:dislikeable_type => klass.to_s).includes(:dislikeable)
+          dislikes.where(:dislikeable_type => klass.to_s).map(&:dislikeable_id)
         end
 
-        disliked.map(&:dislikeable)
+        klass.where('ID IN (?)', ids)
       end
       
       # Get a list of Recommendable::Dislikes with a `#dislikeable_type` of the
@@ -263,7 +261,7 @@ module Recommendable
       #
       # @return [Array] an array of ActiveRecord objects that self has stashed
       def stashed
-        Recommendable.recommendable_classes.flat_map { |klass| stashed_for klass }
+        Recommendable.recommendable_classes.map { |klass| stashed_for klass }.flatten
       end
 
       private
@@ -272,15 +270,15 @@ module Recommendable
       # 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
+      # @return [ActiveRecord::Relation] an ActiveRecord::Relation of records that self has stashed
       def stashed_for klass
-        stashed = if klass.sti?
-          stashed_items.joins manual_join(klass, 'stash')
+        ids = if klass.sti?
+          stashed_items.joins(manual_join(klass, 'stash')).map(&:stashable_id)
         else
-          stashed_items.where(:stashable_type => klass.to_s).includes(:stashable)
+          stashed_items.where(:stashable_type => klass.to_s).map(&:stashable_id)
         end
 
-        stashed.map(&:stashable)
+        klass.where('ID IN (?)', ids)
       end
     end
     
@@ -321,7 +319,7 @@ module Recommendable
       
       # @return [Array] an array of ActiveRecord objects that self has ignored
       def ignored
-        Recommendable.recommendable_classes.flat_map { |klass| ignored_for klass }
+        Recommendable.recommendable_classes.map { |klass| ignored_for klass }.flatten
       end
 
       private
@@ -330,15 +328,15 @@ module Recommendable
       # 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
+      # @return [ActiveRecord::Relation] an ActiveRecord::Relation of records that self has ignored
       def ignored_for klass
-        ignored = if klass.sti?
-          ignores.joins manual_join(klass, 'ignore')
+        ids = if klass.sti?
+          ignores.joins(manual_join(klass, 'ignore')).map(&:ignoreable_id)
         else
-          ignores.where(:ignorable_type => klass.to_s).includes(:ignorable)
+          ignores.where(:ignoreable_type => klass.to_s).map(&:ignoreable_id)
         end
 
-        ignored.map(&:ignorable)
+        klass.where('ID IN (?)', ids)
       end
     end
     
@@ -406,45 +404,42 @@ module Recommendable
       # Recommendations are returned in a descending order with the first index
       # being the object that self has been found most likely to enjoy.
       #
-      # @param [Hash] options the options for returning this list
-      # @option options [Fixnum] :count (10) the number of recommendations to get
+      # @param [Fixnum] count the number of recmomendations to return
       # @return [Array] an array of ActiveRecord objects that are recommendable
-      def recommendations options = {}
+      def recommendations count = 10
         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 }
         
-        recommendations = Recommendable.redis.zrevrange(unioned_predictions, 0, 10).map do |object|
+        recommendations = Recommendable.redis.zrevrange(unioned_predictions, 0, count - 1).map do |object|
           klass, id = object.split(":")
           klass.constantize.find(id)
         end
         
+        recommendations = recommendations.first if count == 1
+
         Recommendable.redis.del(unioned_predictions) and return recommendations
       end
       
-      # Get a list of 10 recommendations for self on a single recommendable type.
+      # Get a list of 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.
-      # @return [Array] an array of ActiveRecord objects that are recommendable
-      def recommended_for klass
-        return [] if likes_for(klass.base_class).count + dislikes_for(klass.base_class).count == 0 || \
-                     Recommendable.redis.zcard(predictions_set_for(klass)) == 0
-      
-        recommendations = []
-        i = 0
-        until recommendations.size == 10
+      # @return [ActiveRecord::Relation] an ActiveRecord::Relation of recommendations
+      def recommended_for klass, count = 10
+        return [] if likes_for(klass.base_class).count + dislikes_for(klass.base_class).count == 0 || Recommendable.redis.zcard(predictions_set_for(klass)) == 0
+        ids = []
+
+        (0...count).each do |i|
           prediction = Recommendable.redis.zrevrange(predictions_set_for(klass), i, i).first
-          return recommendations unless prediction # User might not have enough recommendations to return
+          break unless prediction
           
-          object = klass.to_s.classify.constantize.find(prediction.split(":")[1])
-          recommendations << object
-          i += 1
+          ids << prediction.split(":").last
         end
       
-        return recommendations
+        return klass.to_s.classify.constantize.where('ID IN (?)', ids)
       end
       
       # Return the value calculated by {#predict} on self for a passed object.
@@ -481,9 +476,9 @@ module Recommendable
 
         if options[:class]
           in_common = Recommendable.redis.sinter likes_set_for(options[:class]), rater.likes_set_for(options[:class])
-          in_common = options[:class].to_s.classify.constantize.find in_common if options[:return_records]
+          in_common = options[:class].to_s.classify.constantize.where('ID IN (?)', in_common) if options[:return_records]
         else
-          in_common = Recommendable.recommendable_classes.flat_map do |klass|
+          in_common = Recommendable.recommendable_classes.map do |klass|
             things = Recommendable.redis.sinter(likes_set_for(klass), rater.likes_set_for(klass))
 
             if options[:return_records]
@@ -492,9 +487,11 @@ module Recommendable
               things.map { |id| "#{klass.to_s.classify}:#{id}" }
             end
           end
+
+          in_common.flatten!
         end
 
-        in_common
+        return in_common
       end
       
       # Makes a call to Redis and intersects the sets of dislikes belonging to
@@ -511,9 +508,9 @@ module Recommendable
 
         if options[:class]
           in_common = Recommendable.redis.sinter dislikes_set_for(options[:class]), rater.dislikes_set_for(options[:class])
-          in_common = options[:class].to_s.classify.constantize.find in_common if options[:return_records]
+          in_common = options[:class].to_s.classify.constantize.where('ID IN (?)', in_common) if options[:return_records]
         else
-          in_common = Recommendable.recommendable_classes.flat_map do |klass|
+          in_common = Recommendable.recommendable_classes.map do |klass|
             things = Recommendable.redis.sinter(dislikes_set_for(klass), rater.dislikes_set_for(klass))
 
             if options[:return_records]
@@ -522,6 +519,8 @@ module Recommendable
               things.map { |id| "#{klass.to_s.classify}:#{id}" }
             end
           end
+
+          in_common.flatten!
         end
 
         in_common
@@ -544,9 +543,9 @@ module Recommendable
         if options[:class]
           disagreements =  Recommendable.redis.sinter(likes_set_for(options[:class]), rater.dislikes_set_for(options[:class]))
           disagreements += Recommendable.redis.sinter(dislikes_set_for(options[:class]), rater.likes_set_for(options[:class]))
-          disagreements = options[:class].to_s.classify.constantize.find disagreements if options[:return_records]
+          disagreements = options[:class].to_s.classify.constantize.where('ID IN (?)', disagreements) if options[:return_records]
         else
-          disagreements = Recommendable.recommendable_classes.flat_map do |klass|
+          disagreements = Recommendable.recommendable_classes.map do |klass|
             things = Recommendable.redis.sinter(likes_set_for(klass), rater.dislikes_set_for(klass))
             things += Recommendable.redis.sinter(dislikes_set_for(klass), rater.likes_set_for(klass))
             
@@ -556,6 +555,8 @@ module Recommendable
               things.map { |id| "#{options[:class].to_s.classify}:#{id}" }
             end
           end
+
+          disagreements.flatten!
         end
 
         disagreements
@@ -569,11 +570,8 @@ module Recommendable
       # 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
+        unlike(object) || undislike(object) || unstash(object) || unignore(object)
+        unpredict(object)
       end
 
       # @private

data/lib/recommendable/helpers.rb

@@ -2,7 +2,8 @@ module Recommendable
   module Helpers
     def manual_join(klass, action)
       table = klass.base_class.table_name
-      "JOIN #{table} ON recommendable_#{action.pluralize}.#{action}able_id = #{table}.id AND #{table}.type = '#{klass}'"
+      inheritance_column = klass.base_class.inheritance_column
+      "JOIN #{table} ON recommendable_#{action.pluralize}.#{action}able_id = #{table}.id AND #{table}.#{inheritance_column} = '#{klass}'"
     end
   end
 end

data/lib/recommendable/version.rb

@@ -1,3 +1,3 @@
 module Recommendable
-  VERSION = '0.2.1.1'
+  VERSION = '1.0.0'
 end

data/spec/models/movie_spec.rb

@@ -20,6 +20,19 @@ class MovieSpec < MiniTest::Spec
 
         Movie.top(2).wont_include @movie2
       end
+
+      it "should be removed from recommendations" do
+        @user2 = Factory(:user)
+        @user1.like @movie1
+        @user2.like @movie1
+        @user2.like @movie2
+
+        @user1.send :update_recommendations
+        @movie2.destroy
+
+        @user2.liked.size.must_equal 1
+        @user1.recommendations.size.must_equal 0
+      end
     end
 
     describe ".top" do

data/spec/models/user_spec.rb

@@ -34,7 +34,7 @@ class UserSpec < MiniTest::Spec
       end
     end
 
-    describe "that does not act_as_recommendable" do
+    describe "that does not act_as_recommended_to" do
       before :each do
         @user = Factory(:bully)
         @movie = Factory(:movie)
@@ -186,7 +186,7 @@ class UserSpec < MiniTest::Spec
         @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
+      it "should not be able to rate or ignore an item that is not recommendable." do
         @cakephp = Factory(:php_framework)
         
         proc { @user.like(@cakephp) }.must_raise    Recommendable::RecordNotRecommendableError
@@ -235,6 +235,27 @@ class UserSpec < MiniTest::Spec
         @user.unstash(@movie).must_equal true
       end
     end
+
+    describe "while using finders" do
+      it "should return ActiveRecord::Relations" do
+        @user = Factory(:user)
+        @movie1 = Factory(:movie)
+        @movie2 = Factory(:movie)
+        @movie3 = Factory(:movie)
+        @movie4 = Factory(:movie)
+        @movie5 = Factory(:movie)
+
+        @user.like @movie1
+        @user.like @movie2
+        @user.dislike @movie3
+
+        @user.liked_movies.must_be_instance_of ActiveRecord::Relation
+        @user.liked_movies.where(:title => @movie1.title).must_include @movie1
+        @user.liked_movies.where(:title => @movie2.title).wont_include @movie1
+        @user.liked_movies.limit(1).size.must_equal 1
+        @user.disliked_movies.where(:title => @movie5.title).must_be_empty
+      end
+    end
     
     describe "while getting recommendations" do
       before :each do
@@ -255,6 +276,37 @@ class UserSpec < MiniTest::Spec
         Recommendable.redis.del "User:#{@frank.id}:predictions:Movie"
       end
 
+      it "should respect passed counts" do
+        @dave.like @movie1
+        @frank.like @movie1
+        @frank.like @movie2
+        @frank.like @movie3
+        @frank.like @movie4
+        @frank.like @movie5
+
+        @dave.send :update_similarities and @dave.send :update_recommendations
+
+        @dave.recommendations.size.must_equal 4
+        @dave.recommendations(2).size.must_equal 2
+      end
+
+      it "should return an ActiveRecord::Relation when using the dynamic finder" do
+        @dave.like @movie1
+        @frank.like @movie1
+        @frank.like @movie2
+        @frank.like @movie3
+        @frank.like @movie4
+        @frank.like @movie5
+
+        @dave.send :update_similarities and @dave.send :update_recommendations
+
+        @dave.recommended_movies.limit(2).size.must_equal 2
+        @dave.recommended_movies.where(:title => @movie3.title).must_include @movie3
+        @dave.recommended_movies.where(:title => @movie3.title).wont_include @movie2
+        @dave.recommended_movies.where(:title => @movie3.title).wont_include @movie4
+        @dave.recommended_movies.where(:title => @movie3.title).wont_include @movie5
+      end
+
       it "should have common likes with a friend" do
         @dave.like @movie1
         @dave.like @movie2
@@ -295,6 +347,19 @@ class UserSpec < MiniTest::Spec
         @dave.similar_raters.must_include @frank
         @dave.recommended_movies.must_include @movie2
       end
+
+      it "should return only the number of specified recommendations" do
+        @dave.like(@movie1)
+        @frank.like(@movie1)
+        @frank.like(@movie2)
+        @frank.like(@movie3)
+        @frank.like(@movie4)
+        @dave.send :update_similarities
+        @dave.send :update_recommendations
+
+        @dave.recommendations(2).size.must_equal 2
+        @dave.recommended_movies(1).size.must_equal 1
+      end
       
       it "should order similar users by similarity" do
         @dave.like(@movie1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recommendable
 version: !ruby/object:Gem::Version
-  version: 0.2.1.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-12 00:00:00.000000000 Z
+date: 2012-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3