recommendable 1.1.7 → 2.0.0

data/lib/recommendable/ratable/dislikable.rb

@@ -0,0 +1,26 @@
+module Recommendable
+  module Ratable
+    module Dislikable
+      # Fetch a list of users that have disliked this item.
+      #
+      # @return [Array] a list of users that have disliked this item
+      def disliked_by
+        Recommendable.query(Recommendable.config.user_class, disliked_by_ids)
+      end
+
+      # Get the number of users that have disliked this item
+      #
+      # @return [Fixnum] the number of users that have disliked this item
+      def disliked_by_count
+        Recommendable.redis.scard(Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(self.class, id))
+      end
+
+      # Get the IDs of users that have disliked this item.
+      #
+      # @return [Array] the IDs of users that have disliked this item
+      def disliked_by_ids
+        Recommendable.redis.smembers(Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(self.class, id))
+      end
+    end
+  end
+end

data/lib/recommendable/ratable/likable.rb

@@ -0,0 +1,26 @@
+module Recommendable
+  module Ratable
+    module Likable
+      # Fetch a list of users that have liked this item.
+      #
+      # @return [Array] a list of users that have liked this item
+      def liked_by
+        Recommendable.query(Recommendable.config.user_class, liked_by_ids)
+      end
+
+      # Get the number of users that have liked this item
+      #
+      # @return [Fixnum] the number of users that have liked this item
+      def liked_by_count
+        Recommendable.redis.scard(Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(self.class, id))
+      end
+
+      # Get the IDs of users that have liked this item.
+      #
+      # @return [Array] the IDs of users that have liked this item
+      def liked_by_ids
+        Recommendable.redis.smembers(Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(self.class, id))
+      end
+    end
+  end
+end

data/lib/recommendable/rater.rb

@@ -0,0 +1,109 @@
+require 'recommendable/rater/liker'
+require 'recommendable/rater/disliker'
+require 'recommendable/rater/hider'
+require 'recommendable/rater/bookmarker'
+require 'recommendable/rater/recommender'
+require 'hooks'
+
+module Recommendable
+  module Rater
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def recommends(*things)
+        Recommendable.configure do |config|
+          config.ratable_classes = []
+          config.user_class      = self
+        end
+
+        things.each { |thing| thing.to_s.classify.constantize.make_recommendable! }
+
+        class_eval do
+          include Liker
+          include Disliker
+          include Hider
+          include Bookmarker
+          include Recommender
+          include Hooks
+
+          if ancestors.include?(ActiveRecord::Base) || include?(Mongoid::Document) || include?(MongoMapper::Document) || include?(MongoMapper::EmbeddedDocument)
+            before_destroy :remove_from_recommendable!
+          elsif include?(DataMapper::Resource)
+            before :destroy, :remove_from_recommendable!
+          end
+
+          define_hooks :before_like,     :after_like,     :before_unlike,     :after_unlike,
+                       :before_dislike,  :after_dislike,  :before_undislike,  :after_undislike,
+                       :before_hide,     :after_hide,     :before_unhide,     :after_unhide,
+                       :before_bookmark, :after_bookmark, :before_unbookmark, :after_unbookmark
+
+          before_like    lambda { |obj| undislike(obj) || unhide(obj) }
+          before_dislike lambda { |obj| unlike(obj)    || unhide(obj) }
+
+          %w[like unlike dislike undislike].each do |action|
+            send("after_#{action}", lambda { |obj|
+              Recommendable::Helpers::Calculations.update_score_for(obj.class, obj.id)
+              Recommendable.enqueue(self.id) if Recommendable.config.auto_enqueue
+            })
+          end
+
+          %w[like dislike hide bookmark].each do |action|
+            send("after_#{action}", lambda { |obj| unrecommend(obj) })
+          end
+
+          def method_missing(method, *args, &block)
+            if method.to_s =~ /\A((?:dis)?liked|hidden|bookmarked)_(.+)_in_common_with\z/
+              begin
+                send("#{$1}_in_common_with", $2.classify.constantize, *args)
+              rescue NameError
+                super
+              end
+            elsif method.to_s =~ /\A((?:dis)?liked|hidden|bookmarked)_(.+)_count\z/
+              begin
+                send("#{$1}_count_for", $2.classify.constantize, *args)
+              rescue NameError
+                super
+              end
+            elsif method.to_s =~ /\A((?:dis)?liked|hidden|bookmarked)_(.+)_ids\z/
+              begin
+                send("#{$1}_ids_for", $2.classify.constantize)
+              rescue NameError
+                super
+              end
+            elsif method.to_s =~ /\A((?:dis)?liked|hidden|bookmarked|recommended)_(.+)\z/
+              begin
+                send("#{$1}_for", $2.classify.constantize)
+              rescue NameError
+                super
+              end
+            else
+              super
+            end
+          end
+
+          def respond_to?(method, include_private = false)
+            if method.to_s =~ /\A((?:dis)?liked|hidden|bookmarked)_(.+)_in_common_with\z/ ||
+               method.to_s =~ /\A((?:dis)?liked|hidden|bookmarked)_(.+)_ids\z/ ||
+               method.to_s =~ /\A((?:dis)?liked|hidden|bookmarked|recommended)_(.+)\z/
+              begin
+                true if $2.classify.constantize.recommendable?
+              rescue NameError
+                false
+              end
+            else
+              super
+            end
+          end
+
+          def rated?(obj)
+            likes?(obj) || dislikes?(obj)
+          end
+
+          def rated_anything?
+            likes_count > 0 || dislikes_count > 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/recommendable/rater/bookmarker.rb

@@ -0,0 +1,120 @@
+module Recommendable
+  module Rater
+    module Bookmarker
+      # Bookmark an object. This is not possible if the object is hidden.
+      #
+      # @param [Object] obj the object to be bookmarked
+      # @return true if object was bookmarked successfully
+      # @raise [ArgumentError] if the passed object was not declared ratable
+      def bookmark(obj)
+        raise(ArgumentError, 'Object has not been declared ratable.') unless obj.respond_to?(:recommendable?) && obj.recommendable?
+        return if hides?(obj) || bookmarks?(obj)
+
+        run_hook(:before_bookmark, obj)
+        Recommendable.redis.sadd(Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(obj.class, id), obj.id)
+        run_hook(:after_bookmark, obj)
+
+        true
+      end
+
+      # Check whether the user has bookmarked an object.
+      #
+      # @param [Object] obj the object in question
+      # @return true if the user has bookmarked obj, false if not
+      def bookmarks?(obj)
+        Recommendable.redis.sismember(Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(obj.class, id), obj.id)
+      end
+
+      # Unbookmark an object. This removes the object from a user's set of bookmarks.
+      #
+      # @param [Object] obj the object to be unbookmarked
+      # @return true if the object was bookmarked successfully, nil if the object wasn't already bookmarked
+      def unbookmark(obj)
+        return unless bookmarks?(obj)
+
+        run_hook(:before_unbookmark, obj)
+        Recommendable.redis.srem(Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(obj.class, id), obj.id)
+        run_hook(:after_unbookmark, obj)
+
+        true
+      end
+
+      # Retrieve an array of objects the user has bookmarked
+      #
+      # @return [Array] an array of records
+      def bookmarks
+        Recommendable.config.ratable_classes.map { |klass| bookmarked_for(klass) }.flatten
+      end
+
+      # Retrieve an array of objects both this user and another user have bookmarked
+      #
+      # @return [Array] an array of records
+      def bookmarks_in_common_with(user)
+        Recommendable.config.ratable_classes.map { |klass| bookmarked_in_common_with(klass, user) }.flatten
+      end
+
+      # Get the number of items the user has bookmarked
+      #
+      # @return [Fixnum] the number of bookmarked items
+      def bookmarks_count
+        Recommendable.config.ratable_classes.inject(0) do |sum, klass|
+          sum + bookmarked_count_for(klass)
+        end
+      end
+
+      private
+
+      # Fetch IDs for objects belonging to a passed class that the user has bookmarked
+      #
+      # @param [String, Symbol, Class] the class for which you want IDs
+      # @return [Array] an array of IDs
+      # @private
+      def bookmarked_ids_for(klass)
+        ids = Recommendable.redis.smembers(Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(klass, id))
+        ids.map!(&:to_i) if [:active_record, :data_mapper].include?(Recommendable.config.orm)
+        ids
+      end
+
+      # Fetch records belonging to a passed class that the user has bookmarked
+      #
+      # @param [String, Symbol, Class] the class for which you want bookmarked records
+      # @return [Array] an array of bookmarked records
+      # @private
+      def bookmarked_for(klass)
+        Recommendable.query(klass, bookmarked_ids_for(klass))
+      end
+
+      # Get the number of items belonging to a passed class that the user has bookmarked
+      #
+      # @param [String, Symbol, Class] the class for which you want a count of bookmarks
+      # @return [Fixnum] the number of bookmarks
+      # @private
+      def bookmarked_count_for(klass)
+        Recommendable.redis.scard(Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(klass, id))
+      end
+
+      # Get a list of records that both this user and a passed user have
+      # bookmarked
+      #
+      # @param [User] the other user
+      # @param [String, Symbol, Class] the class of common bookmarked items
+      # @return [Array] an array of records both users have bookmarked
+      # @private
+      def bookmarked_in_common_with(klass, user)
+        Recommendable.query(klass, bookmarked_ids_in_common_with(klass, user))
+      end
+
+      # Get a list of IDs for records that both this user and a passed user have
+      # bookmarked
+      #
+      # @param [User] the other user
+      # @param [String, Symbol, Class] the class of common bookmarked items
+      # @return [Array] an array of IDs for records that both users have bookmarked
+      # @private
+      def bookmarked_ids_in_common_with(klass, user_id)
+        user_id = user_id.id if user_id.is_a?(Recommendable.config.user_class)
+        Recommendable.redis.sinter(Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(klass, id), Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(klass, user_id))
+      end
+    end
+  end
+end

data/lib/recommendable/rater/disliker.rb

@@ -0,0 +1,122 @@
+module Recommendable
+  module Rater
+    module Disliker
+      # Dislike an object. This will remove the item from a user's set of likes
+      # or hidden items
+      #
+      # @param [Object] obj the object to be disliked
+      # @return true if object was disliked successfully
+      # @raise [ArgumentError] if the passed object was not declared ratable
+      def dislike(obj)
+        raise(ArgumentError, 'Object has not been declared ratable.') unless obj.respond_to?(:recommendable?) && obj.recommendable?
+        return if dislikes?(obj)
+
+        run_hook(:before_dislike, obj)
+        Recommendable.redis.sadd(Recommendable::Helpers::RedisKeyMapper.disliked_set_for(obj.class, id), obj.id)
+        Recommendable.redis.sadd(Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(obj.class, obj.id), id)
+        run_hook(:after_dislike, obj)
+
+        true
+      end
+
+      # Check whether the user has disliked an object.
+      #
+      # @param [Object] obj the object in question
+      # @return true if the user has disliked obj, false if not
+      def dislikes?(obj)
+        Recommendable.redis.sismember(Recommendable::Helpers::RedisKeyMapper.disliked_set_for(obj.class, id), obj.id)
+      end
+
+      # Undislike an object. This removes the object from a user's set of dislikes.
+      #
+      # @param [Object] obj the object to be undisliked
+      # @return true if the object was disliked successfully, nil if the object wasn't already disliked
+      def undislike(obj)
+        return unless dislikes?(obj)
+
+        run_hook(:before_undislike, obj)
+        Recommendable.redis.srem(Recommendable::Helpers::RedisKeyMapper.disliked_set_for(obj.class, id), obj.id)
+        Recommendable.redis.srem(Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(obj.class, obj.id), id)
+        run_hook(:after_undislike, obj)
+
+        true
+      end
+
+      # Retrieve an array of objects the user has disliked
+      #
+      # @return [Array] an array of records
+      def dislikes
+        Recommendable.config.ratable_classes.map { |klass| disliked_for(klass) }.flatten
+      end
+
+      # Retrieve an array of objects both this user and another user have disliked
+      #
+      # @return [Array] an array of records
+      def dislikes_in_common_with(user)
+        Recommendable.config.ratable_classes.map { |klass| disliked_in_common_with(klass, user) }.flatten
+      end
+
+      # Get the number of items the user has disliked
+      #
+      # @return [Fixnum] the number of disliked items
+      def dislikes_count
+        Recommendable.config.ratable_classes.inject(0) do |sum, klass|
+          sum + disliked_count_for(klass)
+        end
+      end
+
+      private
+
+      # Fetch IDs for objects belonging to a passed class that the user has disliked
+      #
+      # @param [String, Symbol, Class] the class for which you want IDs
+      # @return [Array] an array of IDs
+      # @private
+      def disliked_ids_for(klass)
+        ids = Recommendable.redis.smembers(Recommendable::Helpers::RedisKeyMapper.disliked_set_for(klass, id))
+        ids.map!(&:to_i) if [:active_record, :data_mapper].include?(Recommendable.config.orm)
+        ids
+      end
+
+      # Fetch records belonging to a passed class that the user has disliked
+      #
+      # @param [String, Symbol, Class] the class for which you want disliked records
+      # @return [Array] an array of disliked records
+      # @private
+      def disliked_for(klass)
+        Recommendable.query(klass, disliked_ids_for(klass))
+      end
+
+      # Get the number of items belonging to a passed class that the user has disliked
+      #
+      # @param [String, Symbol, Class] the class for which you want a count of dislikes
+      # @return [Fixnum] the number of dislikes
+      # @private
+      def disliked_count_for(klass)
+        Recommendable.redis.scard(Recommendable::Helpers::RedisKeyMapper.disliked_set_for(klass, id))
+      end
+
+      # Get a list of records that both this user and a passed user have disliked
+      #
+      # @param [User] the other user
+      # @param [String, Symbol, Class] the class of common disliked items
+      # @return [Array] an array of records both users have disliked
+      # @private
+      def disliked_in_common_with(klass, user)
+        Recommendable.query(klass, disliked_ids_in_common_with(klass, user))
+      end
+
+      # Get a list of IDs for records that both this user and a passed user have
+      # disliked
+      #
+      # @param [User, Fixnum] the other user (or its ID)
+      # @param [String, Symbol, Class] the class of common disliked items
+      # @return [Array] an array of IDs for records that both users have disliked
+      # @private
+      def disliked_ids_in_common_with(klass, user_id)
+        user_id = user_id.id if user_id.is_a?(Recommendable.config.user_class)
+        Recommendable.redis.sinter(Recommendable::Helpers::RedisKeyMapper.disliked_set_for(klass, id), Recommendable::Helpers::RedisKeyMapper.disliked_set_for(klass, user_id))
+      end
+    end
+  end
+end

data/lib/recommendable/rater/hider.rb

@@ -0,0 +1,120 @@
+module Recommendable
+  module Rater
+    module Hider
+      # Hide an object. This action is only possible if the user has not yet
+      # rated or bookmarked the object.
+      #
+      # @param [Object] obj the object to be hidden
+      # @return true if object was hidden successfully
+      # @raise [ArgumentError] if the passed object was not declared ratable
+      def hide(obj)
+        raise(ArgumentError, 'Object has not been declared ratable.') unless obj.respond_to?(:recommendable?) && obj.recommendable?
+        return if likes?(obj) || dislikes?(obj) || bookmarks?(obj) || hides?(obj)
+
+        run_hook(:before_hide, obj)
+        Recommendable.redis.sadd(Recommendable::Helpers::RedisKeyMapper.hidden_set_for(obj.class, id), obj.id)
+        run_hook(:after_hide, obj)
+
+        true
+      end
+
+      # Check whether the user has hidden an object.
+      #
+      # @param [Object] obj the object in question
+      # @return true if the user has hidden obj, false if not
+      def hides?(obj)
+        Recommendable.redis.sismember(Recommendable::Helpers::RedisKeyMapper.hidden_set_for(obj.class, id), obj.id)
+      end
+
+      # Unhide an object. This removes the object from a user's set of hidden items.
+      #
+      # @param [Object] obj the object to be made visible
+      # @return true if the object was successfully made visible, nil if the object wasn't already hidden
+      def unhide(obj)
+        return unless hides?(obj)
+
+        run_hook(:before_unhide, obj)
+        Recommendable.redis.srem(Recommendable::Helpers::RedisKeyMapper.hidden_set_for(obj.class, id), obj.id)
+        run_hook(:after_unhide, obj)
+
+        true
+      end
+
+      # Retrieve an array of objects the user has hidden
+      #
+      # @return [Array] an array of records
+      def hiding
+        Recommendable.config.ratable_classes.map { |klass| hidden_for(klass) }.flatten
+      end
+
+      # Retrieve an array of objects both this user and another user have hidden
+      #
+      # @return [Array] an array of records
+      def hiding_in_common_with(user)
+        Recommendable.config.ratable_classes.map { |klass| hidden_in_common_with(klass, user) }.flatten
+      end
+
+      # Get the number of items the user has hidden
+      #
+      # @return [Fixnum] the number of hidden items
+      def hidden_count
+        Recommendable.config.ratable_classes.inject(0) do |sum, klass|
+          sum + hidden_count_for(klass)
+        end
+      end
+
+      private
+
+      # Fetch IDs for objects belonging to a passed class that the user has hidden
+      #
+      # @param [String, Symbol, Class] the class for which you want IDs
+      # @return [Array] an array of IDs
+      # @private
+      def hidden_ids_for(klass)
+        ids = Recommendable.redis.smembers(Recommendable::Helpers::RedisKeyMapper.hidden_set_for(klass, id))
+        ids.map!(&:to_i) if [:active_record, :data_mapper].include?(Recommendable.config.orm)
+        ids
+      end
+
+      # Fetch records belonging to a passed class that the user has hidden
+      #
+      # @param [String, Symbol, Class] the class for which you want hidden records
+      # @return [Array] an array of hidden records
+      # @private
+      def hidden_for(klass)
+        Recommendable.query(klass, hidden_ids_for(klass))
+      end
+
+      # Get the number of items belonging to a passed class that the user has hidden
+      #
+      # @param [String, Symbol, Class] the class for which you want a count of hidden items
+      # @return [Fixnum] the number of hidden items
+      # @private
+      def hidden_count_for(klass)
+        Recommendable.redis.scard(Recommendable::Helpers::RedisKeyMapper.hidden_set_for(klass, id))
+      end
+
+      # Get a list of records that both this user and a passed user have hidden
+      #
+      # @param [User] the other user
+      # @param [String, Symbol, Class] the class of common hidden items
+      # @return [Array] an array of records both users have hidden
+      # @private
+      def hidden_in_common_with(klass, user)
+        Recommendable.query(klass, hidden_ids_in_common_with(klass, user))
+      end
+
+      # Get a list of IDs for records that both this user and a passed user have
+      # hidden
+      #
+      # @param [User] the other user
+      # @param [String, Symbol, Class] the class of common hidden items
+      # @return [Array] an array of IDs for records that both users have hidden
+      # @private
+      def hidden_ids_in_common_with(klass, user_id)
+        user_id = user_id.id if user_id.is_a?(Recommendable.config.user_class)
+        Recommendable.redis.sinter(Recommendable::Helpers::RedisKeyMapper.hidden_set_for(klass, id), Recommendable::Helpers::RedisKeyMapper.hidden_set_for(klass, user_id))
+      end
+    end
+  end
+end