recommendable 1.1.7 → 2.0.0

data/Rakefile

@@ -1,26 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
-= TODO
-
-* method_missing for User#common_likes_with, User#common_liked_with
-* Use Sidekiq instead?
-* Move dependencies to gemspec instead of Gemfile
-* Support Mongoid (and potentially other ORMs)
-* Allow the option NOT to queue up on like/dislike/ignore?

data/app/models/recommendable/dislike.rb

@@ -1,19 +0,0 @@
-module Recommendable
-  class Dislike < ActiveRecord::Base
-    self.table_name = 'recommendable_dislikes'
-    attr_accessible :user_id, :dislikeable_id, :dislikeable_type
-
-    belongs_to :user, :class_name => Recommendable.user_class.to_s, :foreign_key => :user_id
-    belongs_to :dislikeable, :polymorphic => true
-    
-    validates :user_id, :uniqueness => { :scope => [:dislikeable_id, :dislikeable_type],
-                                         :message => "has already disliked this item" },
-                        :presence => true
-    validates_presence_of :dislikeable_id
-    validates_presence_of :dislikeable_type
-
-    def dislikeable_type=(sType)
-      super sType.to_s.classify.constantize.base_class.to_s
-    end
-  end
-end

data/app/models/recommendable/ignore.rb

@@ -1,19 +0,0 @@
-module Recommendable
-  class Ignore < ActiveRecord::Base
-    self.table_name = 'recommendable_ignores'
-    attr_accessible :user_id, :ignorable_id, :ignorable_type
-
-    belongs_to :user, :class_name => Recommendable.user_class.to_s, :foreign_key => :user_id
-    belongs_to :ignorable, :polymorphic => true
-    
-    validates :user_id, :uniqueness => { :scope => [:ignorable_id, :ignorable_type],
-                                         :message => "has already ignored this item" },
-                        :presence => true
-    validates_presence_of :ignorable_id
-    validates_presence_of :ignorable_type
-    
-    def ignorable_type=(sType)
-      super sType.to_s.classify.constantize.base_class.to_s
-    end
-  end
-end

data/app/models/recommendable/like.rb

@@ -1,19 +0,0 @@
-module Recommendable
-  class Like < ActiveRecord::Base
-    self.table_name = 'recommendable_likes'
-    attr_accessible :user_id, :likeable_id, :likeable_type
-
-    belongs_to :user, :class_name => Recommendable.user_class.to_s, :foreign_key => :user_id
-    belongs_to :likeable, :polymorphic => true, :foreign_key => :likeable_id
-    
-    validates :user_id, :uniqueness => { :scope => [:likeable_id, :likeable_type],
-                                         :message => "has already liked this item" },
-                        :presence => true
-    validates_presence_of :likeable_id
-    validates_presence_of :likeable_type
-
-    def likeable_type=(sType)
-      super sType.to_s.classify.constantize.base_class.to_s
-    end
-  end
-end

data/app/models/recommendable/stash.rb

@@ -1,19 +0,0 @@
-module Recommendable
-  class Stash < ActiveRecord::Base
-    self.table_name = 'recommendable_stashes'
-    attr_accessible :user_id, :stashable_id, :stashable_type
-
-    belongs_to :user, :class_name => Recommendable.user_class.to_s, :foreign_key => :user_id
-    belongs_to :stashable, :polymorphic => :true
-    
-    validates :user_id, :uniqueness => { :scope => [:stashable_id, :stashable_type],
-                                         :message => "has already stashed this item" },
-                        :presence => true
-    validates_presence_of :stashable_id
-    validates_presence_of :stashable_type
-    
-    def stashable_type=(sType)
-      super sType.to_s.classify.constantize.base_class.to_s
-    end
-  end
-end

data/app/workers/recommendable/delayed_job_worker.rb

@@ -1,17 +0,0 @@
-module Recommendable
-  if defined?(Delayed::Job)
-    class DelayedJobWorker
-      attr_accessor :user_id
-  
-      def initialize(user_id)
-        @user_id = user_id
-      end
-      
-      def perform
-        user = Recommendable.user_class.find(self.user_id)
-        user.send :update_similarities
-        user.send :update_recommendations
-      end
-    end
-  end
-end

data/app/workers/recommendable/rails_worker.rb

@@ -1,17 +0,0 @@
-module Recommendable
-  if defined?(Rails::Queueing)
-    class RailsWorker
-      attr_accessor :user_id
-  
-      def initialize(user_id)
-        @user_id = user_id
-      end
-      
-      def run
-        user = Recommendable.user_class.find(self.user_id)
-        user.send :update_similarities
-        user.send :update_recommendations
-      end
-    end
-  end
-end

data/app/workers/recommendable/resque_worker.rb

@@ -1,14 +0,0 @@
-module Recommendable
-  if defined?(Resque)
-    class ResqueWorker
-      include Resque::Plugins::UniqueJob if defined?(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
-end

data/app/workers/recommendable/sidekiq_worker.rb

@@ -1,14 +0,0 @@
-module Recommendable
-  if defined?(Sidekiq)
-    class SidekiqWorker
-      include ::Sidekiq::Worker
-      sidekiq_options :queue => :recommendable, :unique => true
-      
-      def perform(user_id)
-        user = Recommendable.user_class.find(user_id)
-        user.send :update_similarities
-        user.send :update_recommendations
-      end
-    end
-  end
-end

data/config/routes.rb

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

data/db/migrate/20120124193723_create_likes.rb

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

data/db/migrate/20120124193728_create_dislikes.rb

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

data/db/migrate/20120127092558_create_ignores.rb

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

data/db/migrate/20120131173909_create_stashes.rb

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

data/lib/generators/recommendable/USAGE

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

data/lib/generators/recommendable/install_generator.rb

@@ -1,40 +0,0 @@
-require 'rails/generators'
-
-module Recommendable
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-      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
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "redis"
-
-# 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"
-
-# If using Sidekiq, uncomment the following or place it in config/initializers/sidekiq.rb:
-# Sidekiq.configure_server do |config| 	
-#   require 'sidekiq/middleware/server/unique_jobs'
-#   config.server_middleware do |chain|
-#     chain.add Sidekiq::Middleware::Server::UniqueJobs
-#   end	 	
-# end
-# 
-# Sidekiq.configure_client do |config|	 	
-#   require 'sidekiq/middleware/client/unique_jobs'
-#   config.client_middleware do |chain|
-#     chain.add Sidekiq::Middleware::Client::UniqueJobs
-#   end
-# end

data/lib/recommendable/acts_as_recommendable.rb

@@ -1,176 +0,0 @@
-module Recommendable
-  module ActsAsRecommendable
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def acts_as_recommendable
-        class_eval do
-          Recommendable.recommendable_classes << self
-          
-          has_many :recommendable_likes, :as => :likeable, :dependent => :destroy,
-                                         :class_name => "Recommendable::Like"
-          has_many :recommendable_dislikes, :as => :dislikeable, :dependent => :destroy,
-                                            :class_name => "Recommendable::Dislike"
-          has_many :recommendable_ignores, :as => :ignorable, :dependent => :destroy,
-                                           :class_name => "Recommendable::Ignore"
-          has_many :recommendable_stashes, :as => :stashable, :dependent => :destroy,
-                                           :class_name => "Recommendable::Stash"
-
-          has_many :liked_by, :through => :recommendable_likes, :source => :user,
-                              :foreign_key => :user_id, :class_name => Recommendable.user_class.to_s
-          has_many :disliked_by, :through => :recommendable_dislikes, :source => :user,
-                                 :foreign_key => :user_id, :class_name => Recommendable.user_class.to_s
-          
-          include LikeableMethods
-          include DislikeableMethods
-
-          before_destroy :remove_from_scores, :remove_from_recommendations
-          
-          def self.acts_as_recommendable?() true end
-
-          def been_rated?
-            recommendable_likes.count + recommendable_dislikes.count > 0
-          end
-
-          # Returns an array of users that have liked or disliked this item.
-          # @return [Array] an array of users
-          def rated_by
-            liked_by + disliked_by
-          end
-
-          def self.top count = 1
-            ids = Recommendable.redis.zrevrange(self.score_set, 0, count - 1).map(&:to_i)
-
-            items = self.find ids
-            return items.first if count == 1
-
-            return items.sort_by { |item| ids.index(item.id) }
-          end
-
-          private
-
-          def update_score
-            return 0 unless been_rated?
-
-            z = 1.96
-            n = recommendable_likes.count + recommendable_dislikes.count
-
-            phat = recommendable_likes.count / n.to_f
-            score = (phat + z*z/(2*n) - z * Math.sqrt((phat*(1-phat)+z*z/(4*n))/n))/(1+z*z/n)
-
-            Recommendable.redis.zadd self.class.score_set, score, self.id
-            true
-          end
-
-          def remove_from_scores
-            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.
-          # @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.base_class}:#{id}:liked_by"
-            Recommendable.redis.del "#{self.class.base_class}:#{id}: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
-            recommendable_likes.map(&:user_id) + recommendable_dislikes.map(&:user_id)
-          end
-
-          def self.score_set
-            "#{self}:sorted"
-          end
-
-          private :recommendable_likes, :recommendable_dislikes,
-                  :recommendable_ignores, :recommendable_stashes
-        end
-      end
-
-      def acts_as_recommendable?() false end
-
-      def sti?
-        self.base_class != self && self.base_class.table_name == self.table_name
-      end
-
-      private
-    end
-
-    # Instance methods.
-    def recommendable?() self.class.acts_as_recommendable? end
-
-    def redis_key() "#{self.class.base_class}:#{id}" end
-
-    protected :redis_key
-    
-    module LikeableMethods
-      # Retrieve the number of likes this object has received. Cached in Redis.
-      # @return [Fixnum] the number of times this object has been liked
-      def like_count
-        Recommendable.redis.get("#{redis_key}:like_count").to_i
-      end
-
-      private
-
-      # Updates the cache for how many times this object has been liked.
-      # @private
-      def update_like_count
-        Recommendable.redis.set "#{redis_key}:like_count", liked_by.count
-      end
-
-      # 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 = "#{redis_key}:liked_by"
-        liked_by.each { |rater| Recommendable.redis.sadd set, rater.id }
-        return set
-      end
-    end
-    
-    module DislikeableMethods
-      # Retrieve the number of dislikes this object has received. Cached in Redis.
-      # @return [Fixnum] the number of times this object has been disliked
-      def dislike_count
-        Recommendable.redis.get("#{redis_key}:dislike_count").to_i
-      end
-
-      private
-
-      # Updates the cache for how many times this object has been disliked.
-      # @private
-      def update_dislike_count
-        Recommendable.redis.set "#{redis_key}:dislike_count", disliked_by.count
-      end
-
-      # 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 = "#{redis_key}:disliked_by"
-        disliked_by.each { |rater| Recommendable.redis.sadd set, rater.id }
-        return set
-      end
-    end
-  end
-end