leobessa-acts_as_recommendable 0.0.0

data/.gitignore

@@ -0,0 +1 @@
+tmp/

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Made by Many Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,123 @@
+ActsAsRecommendable
+===================
+
+ActsAsRecommendable is a plugin for Rails that simplifies collaborative filtering
+
+The plugin provides a mechanism for finding loose associations between users and items which we can tell you
+* Given a user, return other similar users based on what items they have all bought/bookmarked/rated/etc
+* Given a user, return recommended items based on the items bought/bookmarked/rated/etc by that user and the items bought/bookmarked/rated/etc by other users.
+
+The plugin calculations can be made online and offline and stored using the rails cache (such as memcache) for online retrieval. Online retrieval of recommendations uses item-based collaborative filtering using the offline items similarity matrix stored in the cache. This can give up-to-date results with a much lower processing overhead.
+
+Much thanks to Toby Segaran and his excellent book Programming Collective Intelligence (http://oreilly.com/catalog/9780596529321/).
+
+Features
+========
+
+Use join rating scores
+Using abitary calculated scores
+Similar Items
+Recommended Users
+Cached dataset
+
+Current Release
+===============
+
+v0.1 should be considered early alpha and not ready for production applications.
+
+Lots of performance optimisations still to be done.
+
+Example
+=======
+
+class Book < ActiveRecord::Base
+  has_many :user_books
+  has_many :users, :through => :user_books
+end
+
+class UserBook < ActiveRecord::Base
+  belongs_to :book
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  has_many :user_books
+  has_many :books, :through => :user_books
+  acts_as_recommendable :books, :through => :user_books
+end
+
+user = User.find(:first)
+user.similar_users #=> [...]
+user.recommended_books #=> [...]
+
+book = Book.find(:first)
+book.similar_books #=> [...]
+
+Example 2
+=========
+
+class Movie < ActiveRecord::Base
+  has_many :user_movies
+  has_many :users, :through => :user_movies
+end
+
+class UserMovie < ActiveRecord::Base
+  belongs_to :movie
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  has_many :user_movies
+  has_many :movies, :through => :user_movies
+  acts_as_recommendable :movies, :through => :user_movies, :score => :score
+  # 'score' is an attribute on the users_movies table
+end
+
+user = User.find(:first)
+user.similar_users #=> [...]
+user.recommended_movies #=> [...]
+
+Example 3
+=========
+
+class Book < ActiveRecord::Base
+  has_many :user_books
+  has_many :users, :through => :user_books, :use_dataset => true
+  # Uses cached dataset
+end
+
+class UserBook < ActiveRecord::Base
+  belongs_to :book
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  has_many :user_books
+  has_many :books, :through => :user_books
+  acts_as_recommendable :books, :through => :user_books
+end
+
+user = User.find(:first)
+user.recommended_books #=> [...]
+
+# The example above uses a cached dataset.
+# You need to generate a cached dataset every so often (depending on how much your content changes)
+# You can do that by calling the rake task recommendations:build, you should run this with a cron job every so often.
+
+  
+# If you only want to use the dataset in production put this in production.rb:
+  User.aar_options[:use_dataset] = true
+  
+# Note:
+# user.similar_users doesn't use the dataset
+#
+# The advantage of using a dataset is that you don't need to load all the users & items into
+# memory (which you do normally). The disadvantage is that you won't get as accurate results.
+#
+
+Contact
+=======
+alex@madebymany.co.uk
+
+
+Copyright (c) 2008 Made by Many Ltd, released under the MIT license

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_recommended plugin.'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList.new('test/**/*_test.rb') do |list|
+    list.exclude 'test/test_helper.rb'
+  end
+  test.libs << 'test'
+  test.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_recommendable plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsRecommendable'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "acts_as_recommendable"
+    gemspec.summary = "Colaborative Filtering Library"
+    gemspec.description = "Recommendation engine from the Programming Collective Inteligence book"
+    gemspec.email = "leobessa@gmail.com"
+    gemspec.homepage = "http://github.com/leobessa/acts_as_recommendable"
+    gemspec.authors = ["Leonardo Bessa"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/acts_as_recommendable.gemspec

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_recommendable}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Leonardo Bessa"]
+  s.date = %q{2009-08-07}
+  s.description = %q{Recommendation engine from the Programming Collective Inteligence book}
+  s.email = %q{leobessa@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "acts_as_recommendable.gemspec",
+     "init.rb",
+     "lib/active_record/acts/optimizations.rb",
+     "lib/active_record/acts/recommendable.rb",
+     "tasks/acts_as_recommendable_tasks.rake",
+     "test/.gitignore",
+     "test/recommendable_test.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/leobessa/acts_as_recommendable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Colaborative Filtering Library}
+  s.test_files = [
+    "test/recommendable_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1,3 @@
+$:.unshift "#{File.dirname(__FILE__)}/lib"
+require 'active_record/acts/recommendable'
+ActiveRecord::Base.class_eval { include ActiveRecord::Acts::Recommendable }

data/lib/active_record/acts/optimizations.rb

@@ -0,0 +1,73 @@
+require 'inline'
+module MadeByMany
+  module ActsAsRecommendable
+    class Optimizations
+      InlineC = Module.new do
+        inline do |builder|
+          builder.c '
+          #include <math.h>
+          #include "ruby.h"
+          double c_sim_pearson(VALUE items, int n, VALUE prefs1, VALUE prefs2) {
+            double sum1 = 0.0;
+            double sum2 = 0.0;
+            double sum1Sq = 0.0;
+            double sum2Sq = 0.0;
+            double pSum = 0.0;
+            
+            VALUE *items_a  = RARRAY(items) ->ptr;
+            
+            int i;
+            for(i=0; i<n; i++) {              
+              VALUE prefs1_item_ob;
+              VALUE prefs2_item_ob;
+              
+              double prefs1_item;
+              double prefs2_item;
+              
+              if (!st_lookup(RHASH(prefs1)->tbl, items_a[i], &prefs1_item_ob)) {
+                prefs1_item = 0.0;
+              } else {
+                prefs1_item = NUM2DBL(prefs1_item_ob);
+              }
+              
+              if (!st_lookup(RHASH(prefs2)->tbl, items_a[i], &prefs2_item_ob)) {
+                prefs2_item = 0.0;
+              } else {
+                prefs2_item = NUM2DBL(prefs2_item_ob);
+              }
+                            
+              sum1   += prefs1_item;
+              sum2   += prefs2_item;
+              sum1Sq += pow(prefs1_item, 2);
+              sum2Sq += pow(prefs2_item, 2);
+              pSum   += prefs2_item * prefs1_item;
+            }
+            
+            double num;
+            double den;
+            num = pSum - ( ( sum1 * sum2 ) / n );
+            den = sqrt( ( sum1Sq - ( pow(sum1, 2) ) / n ) * ( sum2Sq - ( pow(sum2, 2) ) / n ) );
+            if(den == 0){
+              return 0.0;
+            } else {
+              return num / den;
+            }
+          }'
+        end
+      end
+      class << self
+        include InlineC
+      end
+    end
+    
+    module Logic  
+      # Pearson score
+      def self.sim_pearson(prefs, items, person1, person2)
+        n = items.length
+        return 0 if n == 0
+        Optimizations.c_sim_pearson(items, n, prefs[person1], prefs[person2])
+      end
+
+    end     
+  end
+end

data/lib/active_record/acts/recommendable.rb

@@ -0,0 +1,367 @@
+# ActsAsRecommended
+module ActiveRecord
+
+  module Acts
+
+    module Recommendable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Send an array to ActiveRecord without fear that some elements don't exist.
+        def find_some_without_failing(ids, options = {})
+          return [] if !ids or ids.empty?
+          conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
+          ids_list   = ids.map { |id| quote_value(id,columns_hash[primary_key]) }.join(',')
+          options.update :conditions => "#{quoted_table_name}.#{connection.quote_column_name(primary_key)} IN (#{ids_list})#{conditions}"
+          result = find_every(options)
+          result
+        end
+
+        def acts_as_recommendable(on, options = {})
+          defaults = {
+            :algorithm      => :sim_pearson,
+            :use_dataset    => false,
+            :split_dataset  => true,
+            :limit          => 10,
+            :min_score      => 0.0
+          }
+
+          options = defaults.merge(options)
+
+          # reflect on the specified association to derive the extra details we need
+          options[:on]          =   on
+          assoc = self.reflections[on.to_sym]
+          through_assoc = assoc.through_reflection
+          options[:through] = through_assoc.name
+          raise "No association specified to recommend." if assoc.nil?
+          raise "The #{on} association does not have a :through association" unless through_assoc
+
+          on_class_name         =   assoc.class_name
+          options[:on_singular] ||= on_class_name.underscore
+          options[:on_class]    ||= assoc.klass
+
+          options[:class] = self
+
+          options[:through_singular]  ||= through_assoc.class_name.downcase
+          options[:through_class]     ||= through_assoc.klass
+
+          class_inheritable_accessor :aar_options
+          self.aar_options = options
+
+          options[:on_class].class_eval do
+            define_method "similar_#{options[:on]}" do
+              Logic.similar_items(self, options)
+            end
+          end
+
+          define_method "similar_#{options[:class].name.underscore.pluralize}" do
+            Logic.similar_users(self, options)
+          end
+
+          define_method "recommended_#{options[:on_class].name.underscore.pluralize}" do
+            if self.aar_options[:use_dataset]
+              Logic.dataset_recommended(self, options)
+            else
+              Logic.recommended(self, options)
+            end
+          end
+
+          define_method "aar_items_with_scores" do
+            @aar_items_with_scores ||= begin
+              self.__send__(self.aar_options[:through]).collect {|ui|
+                item = ui.__send__(self.aar_options[:on_singular])
+                next unless item
+                if self.aar_options[:score]
+                  score = ui.__send__(self.aar_options[:score]).to_f
+                  score = 1.0 if !score or score <= 0
+                else
+                  score = 1.0
+                end
+                def item.aar_score; @aar_score; end
+                def item.aar_score=(d); @aar_score = d; end
+                item.aar_score = score
+                item
+                }.compact.inject({}) {|h, item| h[item.id] = item; h }
+              end
+            end
+
+          end
+        end
+
+        module Logic
+
+          def self.matrix(options)
+            items = options[:on_class].find(:all).collect(&:id)
+            prefs = {}
+            users = options[:class].find(:all, :include => options[:on])
+            users.each do |user|
+              prefs[user.id] ||= {}
+              items.each do |item_id|
+                if user.aar_items_with_scores[item_id]
+                  score = user.aar_items_with_scores[item_id].aar_score
+                  prefs[user.id][item_id] = score
+                end
+              end
+            end
+            [items, prefs]
+          end
+
+          def self.inverted_matrix(options)
+            items = options[:on_class].find(:all).collect(&:id)
+            prefs = {}
+            users = options[:class].find(:all, :include => options[:on])
+            items.each do |item_id|
+              prefs[item_id] ||= {}
+              users.each do |user|
+                if user.aar_items_with_scores[item_id]
+                  score = user.aar_items_with_scores[item_id].aar_score
+                  prefs[item_id][user.id] = score
+                end
+              end
+            end
+            [users.collect(&:id), prefs]
+          end
+
+          # Euclidean distance 
+          def self.sim_distance(prefs, items, person1, person2)
+            return 0 if items.length == 0
+
+            squares = []
+
+            items.each do |item|
+              squares << ((prefs[person1][item] || 0.0) - (prefs[person2][item] || 0.0)) ** 2
+            end
+
+            sum_of_squares = squares.inject { |sum,value| sum += value }
+            return 1/(1 + sum_of_squares)
+          end
+
+          # Pearson score
+          def self.sim_pearson(prefs, items, person1, person2)
+            n = items.length
+            return 0 if n == 0
+
+            sum1 = sum2 = sum1Sq = sum2Sq = pSum = 0.0
+
+            items.each do |item|
+              prefs1_item = prefs[person1][item] || 0.0
+              prefs2_item = prefs[person2][item] || 0.0
+              sum1   += prefs1_item
+              sum2   += prefs2_item
+              sum1Sq += prefs1_item ** 2
+              sum2Sq += prefs2_item ** 2
+              pSum   += prefs2_item * prefs1_item
+            end
+
+            num = pSum - ( ( sum1 * sum2 ) / n )
+            den = Math.sqrt( ( sum1Sq - ( sum1 ** 2 ) / n ) * ( sum2Sq - ( sum2 ** 2 ) / n ) )
+
+            return 0 if den == 0
+
+            num / den
+          end
+
+          def self.similar_users(user, options)
+            rankings = []
+            items, prefs = self.matrix(options)
+            prefs.each do |u, _|
+              next if u == user.id
+              rankings << [self.__send__(options[:algorithm], prefs, items, user.id, u), u]
+            end
+
+            rankings = rankings.select {|score, _| score > options[:min_score] }
+            rankings = rankings.sort_by {|score, _| score }.reverse
+            rankings = rankings[0..(options[:limit] - 1)]
+
+            # Return the sorted list
+            ranking_ids = rankings.collect {|_, u| u }
+            ar_users = options[:class].find_some_without_failing(ranking_ids)
+            ar_users = ar_users.inject({}){ |h, user| h[user.id] = user; h }
+
+            rankings.collect {|score, user_id|
+              user = ar_users[user_id]
+              def user.similar_score; return @similar_score; end
+              def user.similar_score=(d); @similar_score = d; end
+              user.similar_score = score
+              user
+            }
+          end
+
+          def self.similar_items(item, options)
+            if options[:use_dataset]
+              if options[:split_dataset]
+                rankings = Rails.cache.read("aar_#{options[:on]}_#{item.id}")
+              else
+                cached_dataset = Rails.cache.read("aar_#{options[:on]}_dataset")
+                logger.warn 'ActsRecommendable has an empty dataset - rebuild it' unless cached_dataset
+                rankings = cached_dataset && cached_dataset[item.id]
+              end      
+            else
+              users, prefs = self.inverted_matrix(options)
+              rankings = []
+              prefs.each do |i, _|
+                next if i == item.id
+                rankings << [self.__send__(options[:algorithm], prefs, users, item.id, i), i]
+              end
+            end
+            return [] unless rankings
+
+            rankings = rankings.select {|score, _| score > options[:min_score] }
+            rankings = rankings.sort_by {|score, _| score }.reverse
+            rankings = rankings[0..(options[:limit] - 1)]
+
+            # Return the sorted list
+            ranking_ids = rankings.collect {|_, u| u }
+            ar_items = options[:on_class].find_some_without_failing(ranking_ids)
+            ar_items = ar_items.inject({}){ |h, item| h[item.id] = item; h }
+
+            rankings.collect {|score, item_id|
+              item = ar_items[item_id]
+              def item.similar_score; return @similar_score; end
+              def item.similar_score=(d); @similar_score = d; end
+              item.similar_score = score
+              item
+            }
+          end
+
+          def self.recommended(user, options)
+            totals        = {}
+            sim_sums      = {}
+            items, prefs  = self.matrix(options)
+            user          = user.id
+            user_ratings  = prefs[user]
+
+            prefs.keys.each do |other|
+              # don't compare me to myself
+              next if other == user
+
+              sim = self.__send__(options[:algorithm], prefs, items, user, other)
+
+              # ignore scores of zero or lower
+              next if sim <= 0
+
+              prefs[other].keys.each do |item|
+                if !prefs[user].include? item or prefs[user][item] == 0
+                  # similarity * score
+                  totals.default = 0
+                  totals[item] += prefs[other][item] * sim
+                  # sum of similarities
+                  sim_sums.default = 0
+                  sim_sums[item] += sim
+                end
+              end
+            end
+
+            # Create a normalized list
+            rankings = []
+            items = []
+            totals.each do |item,total|
+              rankings << [total/sim_sums[item], item]
+            end
+
+            # Return the sorted list
+            rankings = rankings.select {|score, _| score > options[:min_score] }
+            rankings = rankings.sort_by {|score, _| score }.reverse
+            rankings = rankings[0..(options[:limit] - 1)]
+
+            # So we can do everything in one SQL query
+            ranking_ids = rankings.collect {|_, i| i }
+            ar_items = options[:on_class].find_some_without_failing(ranking_ids)
+            ar_items = ar_items.inject({}){ |h, item| h[item.id] = item; h }
+
+            rankings.collect {|score, item_id|
+              item = ar_items[item_id]
+              def item.recommendation_score; return @recommendation_score; end
+              def item.recommendation_score=(d); @recommendation_score = d; end
+              item.recommendation_score = score
+              item
+            }
+          end
+
+          def self.generate_dataset(options, matrix = nil)
+            users, prefs = matrix || self.inverted_matrix(options)
+            for item in prefs.keys
+              scores = []
+              for other in prefs.keys
+                next if other == item
+                scores << [self.__send__(options[:algorithm], prefs, users, item, other), other]
+              end
+              scores = scores.sort_by {|score, _| score }.reverse
+              yield(item, scores) if block_given?
+            end
+          end
+
+          def self.dataset_recommended(user, options)
+            scores    = {}
+            total_sim = {}
+            items     = user.aar_items_with_scores
+            item_ids  = items.values.collect(&:id)
+            unless options[:split_dataset]
+              cached_dataset = Rails.cache.read("aar_#{options[:on]}_dataset")
+              logger.warn 'ActsRecommendable has an empty dataset - rebuild it' unless cached_dataset
+            end
+
+            item_ids.each do |item_id|
+              if options[:split_dataset] 
+                ratings = Rails.cache.read("aar_#{options[:on]}_#{item_id}")
+              else
+                ratings = cached_dataset && cached_dataset[item_id]
+              end
+              next unless ratings
+
+              ratings.each do |similarity, item2_id|
+                # Ignore if this user has already rated this item
+                next if item_ids.include?(item2_id)
+
+                scores[item2_id]    ||= 0
+                total_sim[item2_id] ||= 0
+                if options[:score]
+                  # Weighted sum of rating times similarity
+                  scores[item2_id]    += similarity * items[item_id].aar_score
+
+                  # Sum of all the similarities
+                  total_sim[item2_id] += similarity
+                else
+                  scores[item2_id]    += similarity 
+                  total_sim[item2_id] += 1.0
+                end
+              end
+            end
+
+            # Divide each total score by total weighting to get an average
+            rankings = []
+            scores.each do |item, score|
+              next unless score > 0.0
+              rankings << [score/total_sim[item], item]
+            end
+
+            rankings = rankings.select {|score, _| score > options[:min_score] }
+            rankings = rankings.sort_by {|score, _| score }.reverse
+            rankings = rankings[0..(options[:limit] - 1)]
+
+            # So we can do everything in one SQL query
+            ranking_ids = rankings.collect {|_, i| i }
+            ar_items = options[:on_class].find_some_without_failing(ranking_ids)
+            ar_items = ar_items.inject({}){ |h, item| h[item.id] = item; h }
+
+            rankings.collect {|score, item_id|
+              item = ar_items[item_id]
+              def item.recommendation_score; @recommendation_score; end
+              def item.recommendation_score=(d); @recommendation_score = d; end
+              item.recommendation_score = score
+              item
+            }
+          end
+
+          def self.logger
+            RAILS_DEFAULT_LOGGER
+          end
+
+        end
+
+      end
+
+    end
+  end

data/tasks/acts_as_recommendable_tasks.rake

@@ -0,0 +1,55 @@
+namespace :recommendations do
+  task :build => [:environment] do
+    MadeByMany::ActsAsRecommendable::Logic.module_eval do
+      # This will need to change to your specific model:
+      options = User.aar_options
+      
+      puts 'Finding items...'
+
+      # You may want to optimize this SQL, like this:
+      # items = options[:on_class].connection.select_values("SELECT id from #{options[:on_class].table_name}").collect(&:to_i)
+      items = options[:on_class].find(:all).collect(&:id)
+      
+      prefs = {}
+      
+      puts 'Finding users...'
+      
+      # You may want to optimize this SQL
+      users = options[:class].find(:all, :include => options[:on])
+      
+      pbar = MadeByMany::ProgressBar.new('Gen matrix', items.length)
+      items.each do |item_id|
+        prefs[item_id] ||= {}
+        users.each do |user|
+          if user.aar_items_with_scores[item_id]
+            score = user.aar_items_with_scores[item_id].aar_score
+            prefs[item_id][user.id] = score
+          end
+        end
+        pbar.inc
+      end
+      pbar.finish
+      matrix = [users.collect(&:id), prefs]
+      
+      pbar = MadeByMany::ProgressBar.new('Gen dataset', prefs.keys.length)
+      
+      if options[:split_dataset]
+        generate_dataset(options, matrix) {|item, scores|
+          Rails.cache.write("aar_#{options[:on]}_#{item}", scores)
+          pbar.inc
+        }
+      else
+        result = {}
+        generate_dataset(options, matrix) {|item, scores|
+          result[item] = scores
+          pbar.inc
+        }
+        Rails.cache.write("aar_#{options[:on]}_dataset", result)
+      end
+      
+      pbar.finish
+      
+      puts 'Rebuild successful'
+    end
+  end
+end

data/test/.gitignore

@@ -0,0 +1,3 @@
+*.sqlite3.db
+*.sqlite3
+*.log

data/test/recommendable_test.rb

@@ -0,0 +1,133 @@
+require 'test/unit'
+
+require 'rubygems'
+gem 'activerecord', '>= 1.15.4.7794'
+gem 'rails'
+require 'active_record'
+
+require "#{File.dirname(__FILE__)}/../init"
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table "books", :force => true do |t|
+      t.string   "name"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    create_table "reviews", :force => true do |t|
+      t.integer "user_id",                :null => false
+      t.integer "book_id",                :null => false
+      t.integer "score",                  :default => 0
+    end
+
+    create_table "users", :force => true do |t|
+      t.string   "name"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class Book < ActiveRecord::Base
+  has_many :reviews
+  has_many :users, :through => :reviews
+end
+
+class Review < ActiveRecord::Base
+  belongs_to :book
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  has_many :reviews
+  has_many :books, :through => :reviews
+  acts_as_recommendable :books, :through => :reviews
+end
+
+class RecommendableTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    @leo  = User.create :name => 'Leo'
+    @bru  = User.create :name => 'Bru'
+    @carol  = User.create :name => 'Carol'
+    @ipod = Book.create :name => 'ipod'
+    @wii  = Book.create :name => 'wii'
+    @bla  = Book.create :name => 'Dr. bla'
+    Review.create(:book => @ipod, :user =>@leo)
+    Review.create(:book => @wii, :user => @leo)
+    Review.create(:book => @wii, :user => @bru)
+    Review.create(:book => @bla, :user => @carol)
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_available_methods
+    user = User.new
+    assert_not_nil user
+    assert_respond_to user, :similar_users
+    assert_respond_to user, :recommended_books
+  end
+
+  def test_similar_users
+    sim_users = @leo.similar_users
+    assert sim_users.include?(@bru)
+  end
+
+  def test_similar_users_format
+    sim_users = @leo.similar_users
+    assert_kind_of Array, sim_users
+    assert_kind_of User, sim_users.first
+    assert_kind_of Numeric, sim_users.first.similar_score
+  end
+
+  def test_similar_users_results
+    sim_users = @leo.similar_users
+    assert sim_users.include?(@bru)
+    assert_respond_to sim_users[0], :similar_score
+    assert !sim_users.include?(@carol)
+  end
+
+  def test_similar_users_scores
+    sim_users = @leo.similar_users
+    assert_respond_to sim_users[0], :similar_score
+    assert sim_users[0].similar_score > 0
+  end
+
+  def test_recommended_books
+    recommended_books = @leo.recommended_books
+    assert_not_nil recommended_books
+  end
+
+  def test_recommended_books_format
+    recommended_books = @bru.recommended_books
+    assert_kind_of Array, recommended_books
+    assert_kind_of Book, recommended_books.first
+    assert_kind_of Numeric, recommended_books.first.recommendation_score
+  end
+
+  def test_recommended_books_results
+    recommended_books = @bru.recommended_books
+    assert_equal true, recommended_books.include?(@ipod)
+    assert recommended_books.find {|b| b == @ipod }.recommendation_score > 0
+  end
+
+  def test_recommended_books_scores
+    recommended_books = @bru.recommended_books
+    assert_respond_to recommended_books[0], :recommendation_score
+    assert recommended_books[0].recommendation_score > 0
+  end
+
+end
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: leobessa-acts_as_recommendable
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Leonardo Bessa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Recommendation engine from the Programming Collective Inteligence book
+email: leobessa@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- acts_as_recommendable.gemspec
+- init.rb
+- lib/active_record/acts/optimizations.rb
+- lib/active_record/acts/recommendable.rb
+- tasks/acts_as_recommendable_tasks.rake
+- test/.gitignore
+- test/recommendable_test.rb
+has_rdoc: true
+homepage: http://github.com/leobessa/acts_as_recommendable
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Colaborative Filtering Library
+test_files: 
+- test/recommendable_test.rb