recommendable 0.1.2

data/Rakefile

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/TODO

@@ -0,0 +1,6 @@
+= TODO
+
+== Next update
+
+* Make public methods to return likes/dislikes that are common between two users
+* Allow the option NOT to queue up on like/dislike/ignore?

data/app/jobs/recommendable/recommendation_refresher.rb

@@ -0,0 +1,12 @@
+module Recommendable
+  class RecommendationRefresher
+    include Resque::Plugins::UniqueJob
+    @queue = :recommendable
+    
+    def self.perform(user_id)
+      user = Recommendable.user_class.find(user_id)
+      user.send :update_similarities
+      user.send :update_recommendations
+    end
+  end
+end

data/app/models/recommendable/dislike.rb

@@ -0,0 +1,9 @@
+module Recommendable
+  class Dislike < ActiveRecord::Base
+    belongs_to :user, :class_name => Recommendable.user_class.to_s
+    belongs_to :dislikeable, :polymorphic => :true
+    
+    validates :user_id, :uniqueness => { :scope => [:dislikeable_id, :dislikeable_type],
+                                         :message => "has already disliked this item" }
+  end
+end

data/app/models/recommendable/ignore.rb

@@ -0,0 +1,9 @@
+module Recommendable
+  class Ignore < ActiveRecord::Base
+    belongs_to :user, :class_name => Recommendable.user_class.to_s
+    belongs_to :ignoreable, :polymorphic => :true
+    
+    validates :user_id, :uniqueness => { :scope => [:ignoreable_id, :ignoreable_type],
+                                         :message => "has already ignored this item" }
+  end
+end

data/app/models/recommendable/like.rb

@@ -0,0 +1,9 @@
+module Recommendable
+  class Like < ActiveRecord::Base
+    belongs_to :user, :class_name => Recommendable.user_class.to_s
+    belongs_to :likeable, :polymorphic => :true
+    
+    validates :user_id, :uniqueness => { :scope => [:likeable_id, :likeable_type],
+                                         :message => "has already liked this item" }
+  end
+end

data/app/models/recommendable/stashed_item.rb

@@ -0,0 +1,9 @@
+module Recommendable
+  class StashedItem < ActiveRecord::Base
+    belongs_to :user, :class_name => Recommendable.user_class.to_s
+    belongs_to :stashable, :polymorphic => :true
+    
+    validates :user_id, :uniqueness => { :scope => [:stashable_id, :stashable_type],
+                                         :message => "has already stashed this item" }
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Recommendable::Engine.routes.draw do
+
+end

data/db/migrate/20120124193723_create_likes.rb

@@ -0,0 +1,17 @@
+class CreateLikes < ActiveRecord::Migration
+  def up
+    create_table :likes do |t|
+      t.references :user
+      t.references :likeable, :polymorphic => true
+      t.timestamps
+    end
+    
+    add_index :likes, :likeable_id
+    add_index :likes, :likeable_type
+    add_index :likes, [:user_id, :likeable_id, :likeable_type], :unique => true, :name => "user_like_constraint"
+  end
+
+  def down
+    drop_table :likes
+  end
+end

data/db/migrate/20120124193728_create_dislikes.rb

@@ -0,0 +1,17 @@
+class CreateDislikes < ActiveRecord::Migration
+  def up
+    create_table :dislikes do |t|
+      t.references :user
+      t.references :dislikeable, :polymorphic => true
+      t.timestamps
+    end
+    
+    add_index :dislikes, :dislikeable_id
+    add_index :dislikes, :dislikeable_type
+    add_index :dislikes, [:user_id, :dislikeable_id, :dislikeable_type], :unique => true, :name => "user_dislike_constraint"
+  end
+
+  def down
+    drop_table :dislikes
+  end
+end

data/db/migrate/20120127092558_create_ignores.rb

@@ -0,0 +1,17 @@
+class CreateIgnores < ActiveRecord::Migration
+  def up
+    create_table :ignores do |t|
+      t.references :user
+      t.references :ignoreable, :polymorphic => true
+      t.timestamps
+    end
+    
+    add_index :ignores, :ignoreable_id
+    add_index :ignores, :ignoreable_type
+    add_index :ignores, [:user_id, :ignoreable_id, :ignoreable_type], :unique => true, :name => "user_ignore_constraint"
+  end
+  
+  def down
+    drop_table :ignores
+  end
+end

data/db/migrate/20120131173909_create_stashed_items.rb

@@ -0,0 +1,17 @@
+class CreateStashedItems < ActiveRecord::Migration
+  def up
+    create_table :stashed_items do |t|
+      t.references :user
+      t.references :stashable, :polymorphic => true
+      t.timestamps
+    end
+    
+    add_index :stashed_items, :stashable_id
+    add_index :stashed_items, :stashable_type
+    add_index :stashed_items, [:user_id, :stashable_id, :stashable_type], :unique => true, :name => "user_stashed_constraint"
+  end
+  
+  def down
+    drop_table :stashed_items
+  end
+end

data/lib/generators/recommendable/USAGE

@@ -0,0 +1,8 @@
+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
+
+    This will create:
+        config/initializers/recommendable.rb

data/lib/generators/recommendable/install_generator.rb

@@ -0,0 +1,47 @@
+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)."
+      class_option :no_migrate,   :type => :boolean, :default => false,             :desc => "Skip migrations. The Like and Dislike tables will not be created."
+      
+      source_root File.expand_path("../templates", __FILE__)
+      
+      def add_recommendable_initializer
+        path = "#{Rails.root}/config/initializers/recommendable.rb"
+        if File.exists?(path)
+          puts "Skipping config/initializers/recommendable.rb creation; file already exists!"
+        else
+          puts "Adding Recommendable initializer (config/initializers/recommendable.rb)"
+          template "initializer.rb", path
+        end
+      end
+      
+      def install_migrations
+        puts "Copying migrations..."
+        Dir.chdir(Rails.root) { puts `rake recommendable:install:migrations` }
+      end
+      
+      def run_migrations
+        unless options[:no_migrate]
+          puts "Running rake db:migrate"
+          puts `rake db:migrate`
+        end
+      end
+      
+      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

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

@@ -0,0 +1,18 @@
+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.
+<% if options.redis_socket %># <% end %>Recommendable.redis = Redis.new(:host => "<%= redis_host %>", :port => <%= redis_port %>)
+
+# Connect to Redis via a UNIX socket instead
+<% unless options.redis_socket %># <% end %>Recommendable.redis = Redis.new(:sock => "<%= options.redis_socket %>")
+
+# 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.rb

@@ -0,0 +1,19 @@
+require 'recommendable/engine'
+require 'recommendable/acts_as_recommended_to'
+require 'recommendable/acts_as_recommendable'
+require 'recommendable/exceptions'
+require 'recommendable/railtie' if defined?(Rails)
+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
+  
+  def self.recommendable_classes
+    @@recommendable_classes ||= []
+  end
+end

data/lib/recommendable/acts_as_recommendable.rb

@@ -0,0 +1,85 @@
+module Recommendable
+  module ActsAsRecommendable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def acts_as_recommendable
+        class_eval do
+          Recommendable.recommendable_classes << self
+          
+          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"
+          
+          include LikeableMethods
+          include DislikeableMethods
+          
+          def self.acts_as_recommendable? ; true ; end
+
+          def has_been_rated?
+            likes.count + dislikes.count > 0
+          end
+          
+          # Used for setup purposes. Calls convenience methods to create sets
+          # in redis of users that both like and dislike this object.
+          # @return [Array] an array containing the liked_by set and the disliked_by set
+          # @private
+          def create_recommendable_sets
+            [create_liked_by_set, create_disliked_by_set]
+          end
+          
+          # Used for teardown purposes. Destroys the sets in redis created by
+          # {#create_recommendable_sets}
+          # @private
+          def destroy_recommendable_sets
+            Recommendable.redis.del "#{self.class}:#{id}:liked_by"
+            Recommendable.redis.del "#{self.class}:#{id}:disliked_by"
+          end
+
+          private :likes, :dislikes, :ignores, :stashes,
+                  :create_recommendable_sets, :destroy_recommendable_sets
+        end
+      end
+
+      def acts_as_recommendable? ; false ; end
+    end
+
+    # Instance methods.
+    def recommendable? ; self.class.acts_as_recommendable? ; end
+
+    def redis_key ; "#{self.class}:#{id}" ; end
+
+    protected :redis_key
+    
+    module LikeableMethods
+      # Used for setup purposes. Creates a set in redis containing users that
+      # have liked this object.
+      # @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}
+        return set
+      end
+
+      private :create_liked_by_set
+    end
+    
+    module DislikeableMethods
+      # Used for setup purposes. Creates a set in redis containing users that
+      # have disliked this object.
+      # @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}
+        return set
+      end
+
+      private :create_disliked_by_set
+    end
+  end
+end

data/lib/recommendable/acts_as_recommended_to.rb

@@ -0,0 +1,659 @@
+require 'active_support/concern'
+
+module Recommendable
+  module ActsAsRecommendedTo
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def acts_as_recommended_to
+        class_eval do
+          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
+          
+          include LikeMethods
+          include DislikeMethods
+          include StashMethods
+          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
+      # Recommendable::Dislike will be destroyed. It will also be removed from
+      # the user's stash or ignores.
+      #
+      # @param [Object] object the object you want self to like.
+      # @return true if object has been liked
+      # @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)
+        undislike(object)
+        unstash(object)
+        unignore(object)
+        unpredict(object)
+        likes.create!(:likeable_id => object.id, :likeable_type => object.class.to_s)
+        Resque.enqueue RecommendationRefresher, self.id
+        true
+      end
+      
+      # Checks to see if self has already liked a passed object.
+      # 
+      # @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)
+      end
+      
+      # Destroys a Recommendable::Like currently associating self with object
+      #
+      # @param [Object] object the object you want to remove from self's likes
+      # @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
+          true
+        end
+      end
+      
+      # Get a list of records that self currently likes
+      
+      # @return [Array] an array of ActiveRecord objects that self has liked
+      def liked
+        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)
+      end
+
+      alias_method :liked_records_for, :liked_for
+      private :likes_for
+    end
+    
+    module DislikeMethods
+      # Creates a Recommendable::Dislike to associate self to a passed object. If
+      # self is currently found to have liked object, the corresponding
+      # Recommendable::Like will be destroyed. It will also be removed from the
+      # user's stash or list of ignores.
+      #
+      # @param [Object] object the object you want self to dislike.
+      # @return true if object has been disliked
+      # @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)
+        unlike(object)
+        unstash(object)
+        unignore(object)
+        unpredict(object)
+        dislikes.create!(:dislikeable_id => object.id, :dislikeable_type => object.class.to_s)
+        Resque.enqueue RecommendationRefresher, self.id
+        true
+      end
+      
+      # Checks to see if self has already disliked a passed object.
+      # 
+      # @param [Object] object the object you want to check
+      # @return true if self dislikes object, false if not
+      def dislikes?(object)
+        dislikes.exists?(:dislikeable_id => object.id, :dislikeable_type => object.class.to_s)
+      end
+      
+      # Destroys a Recommendable::Dislike currently associating self with object
+      #
+      # @param [Object] object the object you want to remove from self's dislikes
+      # @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
+          true
+        end
+      end
+      
+      # Get a list of records that self currently dislikes
+      
+      # @return [Array] an array of ActiveRecord objects that self has disliked
+      def disliked
+        dislikes.map {|dislike| dislike.dislikeable}
+      end
+
+      alias_method :disliked_records, :disliked
+      
+      # Get a list of Recommendable::Dislikes with a `#dislikeable_type` of the
+      # passed class.
+      #
+      # @param [Class, String, Symbol] klass the class for which you would like to return self's dislikes. Can be the class constant, or a String/Symbol representation of the class name.
+      # @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)
+      end
+
+      alias_method :disliked_records_for, :disliked_for
+      private :dislikes_for
+    end
+
+    module StashMethods
+      # Creates a Recommendable::StashedItem to associate self to a passed object.
+      # This will remove the item from this user's recommendations.
+      # If self is currently found to have liked or disliked the object, nothing
+      # will happen. It will, however, be unignored.
+      #
+      # @param [Object] object the object you want self to stash.
+      # @return true if object has been stashed
+      # @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)
+        unignore(object)
+        unpredict(object)
+        stashed_items.create!(:stashable_id => object.id, :stashable_type => object.class.to_s)
+        true
+      end
+      
+      # Checks to see if self has already stashed a passed object for later.
+      # 
+      # @param [Object] object the object you want to check
+      # @return true if self has stashed object, false if not
+      def has_stashed?(object)
+        stashed_items.exists?(:stashable_id => object.id, :stashable_type => object.class.to_s)
+      end
+      
+      # Destroys a Recommendable::StashedItem currently associating self with object
+      #
+      # @param [Object] object the object you want to remove from self's stash
+      # @return true if object is stashed, nil if nothing happened
+      def unstash(object)
+        true if stashed_items.where(:stashable_id => object.id, :stashable_type => object.class.to_s).first.try(:destroy)
+      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)
+      end
+
+      alias_method :stashed_records_for, :stashed_for
+      private :stash_for
+    end
+    
+    module IgnoreMethods
+      # Creates a Recommendable::Ignore to associate self to a passed object. If
+      # self is currently found to have liked or dislikedobject, the
+      # corresponding Recommendable::Like or Recommendable::Dislike will be
+      # destroyed.
+      #
+      # @param [Object] object the object you want self to ignore.
+      # @return true if object has been ignored
+      # @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)
+        unlike(object)
+        undislike(object)
+        unstash(object)
+        unpredict(object)
+        ignores.create!(:ignoreable_id => object.id, :ignoreable_type => object.class.to_s)
+        true
+      end
+      
+      # Checks to see if self has already ignored a passed object.
+      # 
+      # @param [Object] object the object you want to check
+      # @return true if self has ignored object, false if not
+      def has_ignored?(object)
+        ignores.exists?(:ignoreable_id => object.id, :ignoreable_type => object.class.to_s)
+      end
+      
+      # Destroys a Recommendable::Ignore currently associating self with object
+      #
+      # @param [Object] object the object you want to remove from self's ignores
+      # @return true if object is removed from self's ignores, nil if nothing happened
+      def unignore(object)
+        true if ignores.where(:ignoreable_id => object.id, :ignoreable_type => object.class.to_s).first.try(:destroy)
+      end
+      
+      # Get a list of records that self is currently ignoring
+      
+      # @return [Array] an array of ActiveRecord objects that self has ignored
+      def ignored
+        ignores.map {|ignore| ignore.ignoreable}
+      end
+
+      alias_method :ignored_records, :ignored
+      
+      # 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 => klassify(klass).to_s)
+      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
+      def self.acts_as_recommended_to? ; true ; end
+
+      def can_receive_recommendations? ; self.class.acts_as_recommended_to? ; end
+
+      # Checks to see if self has already liked or disliked a passed object.
+      # 
+      # @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)
+        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?
+        likes.count > 0 || dislikes.count > 0
+      end
+      
+      # Get a list of raters that have been found to be the most similar to
+      # self. They are sorted in a descending fashion with the most similar
+      # rater in the first index.
+      #
+      # @param [Hash] options the options for this query
+      # @option options [Fixnum] :count (10) The number of raters to return
+      # @return [Array] An array of instances of your user class
+      def similar_raters(options = {})
+        defaults = { :count => 10 }
+        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)
+        
+        # The query loses the ordering, so...
+        return raters.sort do |x, y|
+          rater_ids.index(x.id) <=> rater_ids.index(y.id)
+        end
+      end
+      
+      # Get a list of recommendations for self. The whole point of this gem!
+      # 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
+      # @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)}
+        return [] if Recommendable.redis.zcard(unioned_predictions) == 0
+        
+        recommendations = Recommendable.redis.zrevrange(unioned_predictions, 0, options[:count]).map do |object|
+          klass, id = object.split(":")
+          klass.constantize.find(id)
+        end
+        
+        Recommendable.redis.del unioned_predictions
+        return recommendations
+      end
+      
+      # 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.
+      # @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
+        
+        recommendations = []
+        return recommendations if likes_for(klass).count + dislikes_for(klass).count == 0 || Recommendable.redis.zcard(predictions_set_for(klass)) == 0
+      
+        i = 0
+        until recommendations.size == options[:count]
+          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])
+          recommendations << object unless has_ignored?(object)
+          i += 1
+        end
+      
+        return recommendations
+      end
+      
+      # Return the value calculated by {#predict} on self for a passed object.
+      #
+      # @param [Object] object the object to fetch the probability for
+      # @return [Float] the likelihood of self liking the passed object
+      def probability_of_liking(object)
+        Recommendable.redis.zscore predictions_set_for(object.class), object.redis_key
+      end
+      
+      # Return the negation of the value calculated by {#predict} on self
+      # for a passed object.
+      #
+      # @param [Object] object the object to fetch the probability for
+      # @return [Float] the likelihood of self disliking the passed object
+      # @see #probability of liking
+      def probability_of_disliking(object)
+        -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).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.
+      #
+      # @param [Object] rater the person whose set of likes you wish to intersect with that of self
+      # @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
+      def common_likes_with(rater, options = {})
+        defaults = { :class => nil,
+                     :return_records => true }
+        options = defaults.merge(options)
+        
+        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]
+        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 if options[:return_records]
+            else
+              in_common.map {|id| "#{klassify(klass)}:#{id}"}
+            end
+          end
+        end
+      end
+      
+      # Makes a call to Redis and intersects the sets of dislikes belonging to
+      # self and rater.
+      #
+      # @param [Object] rater the person whose set of dislikes you wish to intersect with that of self
+      # @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
+      def common_dislikes_with(rater, options = {})
+        defaults = { :class => nil,
+                     :return_records => true }
+        options = defaults.merge(options)
+        
+        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]
+        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 if options[:return_records]
+            else
+              in_common.map {|id| "#{klassify(klass)}:#{id}"}
+            end
+          end
+        end
+      end
+      
+      # Makes a call to Redis and intersects self's set of likes with rater's
+      # set of dislikes and vise versa. The idea here is that if self likes
+      # an object that rater dislikes, it is a disagreement and should count
+      # negatively towards their similarity.
+      #
+      # @param [Object] rater the person whose sets you wish to intersect with those of self
+      # @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
+      def disagreements_with(rater, options = {})
+        defaults = { :class => nil,
+                     :return_records => true }
+        options = defaults.merge(options)
+        
+        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]
+        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
+            else
+              disagreements.map {|id| "#{klassify(klass)}:#{id}"}
+            end
+          end
+        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
+      # indicate a rising probability of liking the passed object while values
+      # approaching -Infinity indicate a rising probability of disliking the
+      # passed object.
+      #
+      # @param [Object] object the object to check the likeliness of liking
+      # @return [Float] the probability that self will like object
+      # @private
+      def predict(object)
+        liked_by, disliked_by = object.send :create_recommendable_sets
+        rated_by = Recommendable.redis.scard(liked_by) + Recommendable.redis.scard(disliked_by)
+        similarity_sum = 0.0
+        prediction = 0.0
+      
+        Recommendable.redis.smembers(liked_by).inject(similarity_sum) {|sum, r| sum += Recommendable.redis.zscore(similarity_set, r).to_f }
+        Recommendable.redis.smembers(disliked_by).inject(similarity_sum) {|sum, r| sum -= Recommendable.redis.zscore(similarity_set, r).to_f }
+      
+        prediction = similarity_sum / rated_by.to_f
+        
+        object.send :destroy_recommendable_sets
+        
+        return prediction
+      end
+      
+      # Used internally to update the similarity values between self and all
+      # other users. This is called in the Resque job to refresh recommendations.
+      #
+      # @private
+      def update_similarities
+        return unless has_rated_anything?
+        create_recommended_to_sets
+        
+        Recommendable.user_class.find_each do |rater|
+          next if self == rater || !rater.can_rate?
+          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
+      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"
+      end
+      
+      # @private
+      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
+
+      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