recommendable 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c4bb9e3b50bed189b31f1a4eaeb4b1a368c2aeda
-  data.tar.gz: 786fbed254bce107f4fb23885ee8014b069a1149
+SHA256:
+  metadata.gz: bed9eb66adf5e636014b2f559c0f0c68542c778437bc177dfd4ce107fd7cbead
+  data.tar.gz: e37871a3954bc1032249c6b5920193cddd0897f340d0fc9bda9f9ffd4ca761e3
 SHA512:
-  metadata.gz: 1a409bcc8d2a9ab2f1313045503461630f1b2b8ff43e824b63a1a08a562b8196c169c4ebd5996af4c4f9e565486d0f37accd946c0501e8fc144e7e2c26944920
-  data.tar.gz: 15f55ac0d5a380a92e72c6b59743043e124855021568ea70bdae6a3096581bd755e7e76820e2eff4aa2f4884b9a0618480e5f9b6df3d6b38cd23fe03942bdca2
+  metadata.gz: ff226a0223b80b733d4ea0ff04805c343e9d4e6baa9376c1f5fb07ffab69559030ae0fe9a3680f6883c0991aed2073cd296ada67a1446132ba7e5dac9f318df9
+  data.tar.gz: 9c3e92781cb02678ca928bfe66637071c38ddd14fc41936374235f22227b7030d0691232a99fa71e94f529ccbbf4bde73ea8ec79484e8303d3ef6b6e543e5563

data/lib/recommendable/helpers/calculations.rb

@@ -125,7 +125,7 @@ module Recommendable
             end
 
             # Get dislikes from the least similar users
-            least_similar_user_ids.inject(sets_to_union) do |sets, id|
+            sets_to_union = least_similar_user_ids.inject(sets_to_union) do |sets, id|
               sets << Recommendable::Helpers::RedisKeyMapper.disliked_set_for(klass, id)
             end
 

data/lib/recommendable/helpers/queriers.rb

@@ -6,6 +6,8 @@ module Recommendable
           klass.where(:id => ids)
         end
 
+        alias_method :active_record_uuid, :active_record
+
         def data_mapper(klass, ids)
           klass.all(:id => ids)
         end

data/lib/recommendable/helpers/redis_key_mapper.rb

@@ -31,7 +31,13 @@ module Recommendable
         private
 
         def redis_namespace
-          Recommendable.config.redis_namespace
+          name_space = Recommendable.config.redis_namespace
+          case
+          when name_space.kind_of?(Proc)
+            return name_space.call
+          else
+            return name_space
+          end
         end
 
         def user_namespace

data/lib/recommendable/orm/active_record_uuid.rb

@@ -0,0 +1,6 @@
+require 'active_record'
+
+ActiveRecord::Base.send(:include, Recommendable::Rater)
+ActiveRecord::Base.send(:include, Recommendable::Ratable)
+
+Recommendable.configure { |config| config.orm = :active_record_uuid }

data/lib/recommendable/rater/bookmarker.rb

@@ -62,13 +62,10 @@ module Recommendable
         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, :sequel].include?(Recommendable.config.orm)
@@ -79,7 +76,6 @@ module Recommendable
       #
       # @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
@@ -88,7 +84,6 @@ module Recommendable
       #
       # @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
@@ -99,7 +94,6 @@ module Recommendable
       # @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
@@ -110,7 +104,6 @@ module Recommendable
       # @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))

data/lib/recommendable/rater/disliker.rb

@@ -65,13 +65,10 @@ module Recommendable
         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, :sequel].include?(Recommendable.config.orm)
@@ -82,7 +79,6 @@ module Recommendable
       #
       # @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
@@ -91,7 +87,6 @@ module Recommendable
       #
       # @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
@@ -101,7 +96,6 @@ module Recommendable
       # @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
@@ -112,7 +106,6 @@ module Recommendable
       # @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))

data/lib/recommendable/rater/hider.rb

@@ -63,13 +63,10 @@ module Recommendable
         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, :sequel].include?(Recommendable.config.orm)
@@ -80,7 +77,6 @@ module Recommendable
       #
       # @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
@@ -89,7 +85,6 @@ module Recommendable
       #
       # @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
@@ -99,7 +94,6 @@ module Recommendable
       # @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
@@ -110,7 +104,6 @@ module Recommendable
       # @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))

data/lib/recommendable/rater/liker.rb

@@ -65,13 +65,10 @@ module Recommendable
         end
       end
 
-      private
-
       # Fetch IDs for objects belonging to a passed class that the user has liked
       #
       # @param [String, Symbol, Class] the class for which you want IDs
       # @return [Array] an array of IDs
-      # @private
       def liked_ids_for(klass)
         ids = Recommendable.redis.smembers(Recommendable::Helpers::RedisKeyMapper.liked_set_for(klass, id))
         ids.map!(&:to_i) if [:active_record, :data_mapper, :sequel].include?(Recommendable.config.orm)
@@ -82,7 +79,6 @@ module Recommendable
       #
       # @param [String, Symbol, Class] the class for which you want liked records
       # @return [Array] an array of liked records
-      # @private
       def liked_for(klass)
         Recommendable.query(klass, liked_ids_for(klass))
       end
@@ -91,7 +87,6 @@ module Recommendable
       #
       # @param [String, Symbol, Class] the class for which you want a count of likes
       # @return [Fixnum] the number of likes
-      # @private
       def liked_count_for(klass)
         Recommendable.redis.scard(Recommendable::Helpers::RedisKeyMapper.liked_set_for(klass, id))
       end
@@ -101,7 +96,6 @@ module Recommendable
       # @param [User] the other user
       # @param [String, Symbol, Class] the class of common liked items
       # @return [Array] an array of records both users have liked
-      # @private
       def liked_in_common_with(klass, user)
         Recommendable.query(klass, liked_ids_in_common_with(klass, user))
       end
@@ -112,7 +106,6 @@ module Recommendable
       # @param [User, Fixnum] the other user (or its ID)
       # @param [String, Symbol, Class] the class of common liked items
       # @return [Array] an array of IDs for records that both users have liked
-      # @private
       def liked_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.liked_set_for(klass, id), Recommendable::Helpers::RedisKeyMapper.liked_set_for(klass, user_id))

data/lib/recommendable/rater/recommender.rb

@@ -4,30 +4,36 @@ module Recommendable
       # Get a list of raters that have been found to be the most similar to
       # self. They are sorted by the calculated similarity value.
       #
-      # @param [Fixnum] count the number of users to return (defaults to 10)
+      # @param [Fixnum] limit the number of users to return (defaults to 10)
       # @return [Array] An array of instances of your user class
-      def similar_raters(count = 10, offset = 0)
-        ids = Recommendable.redis.zrevrange(Recommendable::Helpers::RedisKeyMapper.similarity_set_for(id), offset, count - 1)
-        Recommendable.query(self.class, ids).sort_by { |user| ids.index(user.id.to_s) }
-      end
+      def similar_raters(limit = 10, offset = 0)
+        ids = Recommendable.redis.zrevrange(Recommendable::Helpers::RedisKeyMapper.similarity_set_for(id), 0, -1)
 
-      private
+        order = ids.map { |id| "#{Recommendable.config.user_class.quoted_table_name}.#{Recommendable.config.user_class.quoted_primary_key} = %d DESC" }.join(', ')
+        order = self.class.send(:sanitize_sql_for_assignment, [order, *ids])
+
+        Recommendable.query(self.class, ids).order(order).limit(limit).offset(offset)
+      end
 
       # Fetch a list of recommendations for a passed class.
       #
       # @param [String, Symbol, Class] klass the class from which to get recommendations
-      # @param [Fixnum] count the number of recommendations to fetch (defaults to 10)
+      # @param [Fixnum] limit the number of recommendations to fetch (defaults to 10)
       # @return [Array] a list of things this person's gonna love
-      def recommended_for(klass, count = 10, offset = 0)
+      def recommended_for(klass, limit = 10, offset = 0)
         recommended_set = Recommendable::Helpers::RedisKeyMapper.recommended_set_for(klass, self.id)
         return Recommendable.query(klass, []) unless rated_anything? && Recommendable.redis.zcard(recommended_set) > 0
 
-        ids = Recommendable.redis.zrevrange(recommended_set, offset, count - 1, :with_scores => true)
+        ids = Recommendable.redis.zrevrange(recommended_set, 0, -1, :with_scores => true)
         ids = ids.select { |id, score| score > 0 }.map { |pair| pair.first }
 
-        Recommendable.query(klass, ids).sort_by { |record| ids.index(record.id.to_s) }
+        order = ids.map { |id| "#{klass.quoted_table_name}.#{klass.quoted_primary_key} = %d DESC" }.join(', ')
+        order = klass.send(:sanitize_sql_for_assignment, [order, *ids])
+        Recommendable.query(klass, ids).order(order).limit(limit).offset(offset)
       end
 
+      private
+
       # Removes an item from a user's set of recommendations
       # @private
       def unrecommend(obj)

data/lib/recommendable/version.rb

@@ -2,7 +2,7 @@ module Recommendable
   class Version
     MAJOR = 2
     MINOR = 2
-    PATCH = 0
+    PATCH = 1
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/test/dummy/config/initializers/recommendable.rb

@@ -3,4 +3,5 @@ require 'redis'
 
 Recommendable.configure do |config|
   config.redis = Redis.new(:host => 'localhost', :port => 6379, :db => 15)
+  config.user_class = User
 end

data/test/recommendable/helpers/calculations_test.rb

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
 require 'test_helper'
 
-class CalculationsTest < MiniTest::Unit::TestCase
+class CalculationsTest < Minitest::Test
   def setup
     @user = Factory(:user)
     5.times  { |x| instance_variable_set(:"@user#{x+1}",  Factory(:user))  }

data/test/recommendable/helpers/redis_key_mapper_test.rb

@@ -1,105 +1,216 @@
 $LOAD_PATH.unshift File.expand_path('../../test', __FILE__)
 require 'test_helper'
 
-class RedisKeyMapperTest < MiniTest::Unit::TestCase
-  def test_output_of_liked_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_set_for(Movie, 1), 'recommendable:users:1:liked_movies'
-  end
+class RedisKeyMapperTest < Minitest::Test
+  describe "with default namespace" do
+    def test_output_of_liked_set_for
+      assert_equal 'recommendable:users:1:liked_movies', Recommendable::Helpers::RedisKeyMapper.liked_set_for(Movie, 1)
+    end
 
-  def test_output_of_disliked_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Movie, 1), 'recommendable:users:1:disliked_movies'
-  end
+    def test_output_of_disliked_set_for
+      assert_equal 'recommendable:users:1:disliked_movies', Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Movie, 1)
+    end
 
-  def test_output_of_hidden_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Movie, 1), 'recommendable:users:1:hidden_movies'
-  end
+    def test_output_of_hidden_set_for
+      assert_equal 'recommendable:users:1:hidden_movies', Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Movie, 1)
+    end
 
-  def test_output_of_bookmarked_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Movie, 1), 'recommendable:users:1:bookmarked_movies'
-  end
+    def test_output_of_bookmarked_set_for
+      assert_equal 'recommendable:users:1:bookmarked_movies', Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Movie, 1)
+    end
 
-  def test_output_of_recommended_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Movie, 1), 'recommendable:users:1:recommended_movies'
-  end
+    def test_output_of_recommended_set_for
+      assert_equal 'recommendable:users:1:recommended_movies', Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Movie, 1)
+    end
 
-  def test_output_of_similarity_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.similarity_set_for(1), 'recommendable:users:1:similarities'
-  end
+    def test_output_of_similarity_set_for
+      assert_equal 'recommendable:users:1:similarities', Recommendable::Helpers::RedisKeyMapper.similarity_set_for(1)
+    end
 
-  def test_output_of_liked_by_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Movie, 1), 'recommendable:movies:1:liked_by'
-  end
+    def test_output_of_liked_by_set_for
+      assert_equal 'recommendable:movies:1:liked_by', Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Movie, 1)
+    end
 
-  def test_output_of_disliked_by_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Movie, 1), 'recommendable:movies:1:disliked_by'
-  end
+    def test_output_of_disliked_by_set_for
+      assert_equal 'recommendable:movies:1:disliked_by', Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Movie, 1)
+    end
 
-  def test_output_of_score_set_for
-    assert_equal Recommendable::Helpers::RedisKeyMapper.score_set_for(Movie), 'recommendable:movies:scores'
-  end
+    def test_output_of_score_set_for
+      assert_equal 'recommendable:movies:scores', Recommendable::Helpers::RedisKeyMapper.score_set_for(Movie)
+    end
 
-  def test_output_of_liked_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_set_for(Documentary, 1), 'recommendable:users:1:liked_movies'
-  end
+    def test_output_of_liked_set_for_subclass_of_ratable
+      assert_equal 'recommendable:users:1:liked_movies', Recommendable::Helpers::RedisKeyMapper.liked_set_for(Documentary, 1)
+    end
 
-  def test_output_of_disliked_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Documentary, 1), 'recommendable:users:1:disliked_movies'
-  end
+    def test_output_of_disliked_set_for_subclass_of_ratable
+      assert_equal 'recommendable:users:1:disliked_movies', Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Documentary, 1)
+    end
 
-  def test_output_of_hidden_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Documentary, 1), 'recommendable:users:1:hidden_movies'
-  end
+    def test_output_of_hidden_set_for_subclass_of_ratable
+      assert_equal 'recommendable:users:1:hidden_movies', Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Documentary, 1)
+    end
 
-  def test_output_of_bookmarked_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Documentary, 1), 'recommendable:users:1:bookmarked_movies'
-  end
+    def test_output_of_bookmarked_set_for_subclass_of_ratable
+      assert_equal 'recommendable:users:1:bookmarked_movies', Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Documentary, 1)
+    end
 
-  def test_output_of_recommended_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Documentary, 1), 'recommendable:users:1:recommended_movies'
-  end
+    def test_output_of_recommended_set_for_subclass_of_ratable
+      assert_equal 'recommendable:users:1:recommended_movies', Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Documentary, 1)
+    end
 
-  def test_output_of_liked_by_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Documentary, 1), 'recommendable:movies:1:liked_by'
-  end
+    def test_output_of_liked_by_set_for_subclass_of_ratable
+      assert_equal 'recommendable:movies:1:liked_by', Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Documentary, 1)
+    end
 
-  def test_output_of_disliked_by_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Documentary, 1), 'recommendable:movies:1:disliked_by'
-  end
+    def test_output_of_disliked_by_set_for_subclass_of_ratable
+      assert_equal 'recommendable:movies:1:disliked_by', Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Documentary, 1)
+    end
 
-  def test_output_of_score_set_for_subclass_of_ratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.score_set_for(Documentary), 'recommendable:movies:scores'
-  end
+    def test_output_of_score_set_for_subclass_of_ratable
+      assert_equal 'recommendable:movies:scores', Recommendable::Helpers::RedisKeyMapper.score_set_for(Documentary)
+    end
 
-  def test_output_of_liked_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_set_for(Car, 1), 'recommendable:users:1:liked_cars'
-  end
+    def test_output_of_liked_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:users:1:liked_cars', Recommendable::Helpers::RedisKeyMapper.liked_set_for(Car, 1)
+    end
 
-  def test_output_of_disliked_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Car, 1), 'recommendable:users:1:disliked_cars'
-  end
+    def test_output_of_disliked_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:users:1:disliked_cars', Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Car, 1)
+    end
 
-  def test_output_of_hidden_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Car, 1), 'recommendable:users:1:hidden_cars'
-  end
+    def test_output_of_hidden_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:users:1:hidden_cars', Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Car, 1)
+    end
 
-  def test_output_of_bookmarked_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Car, 1), 'recommendable:users:1:bookmarked_cars'
-  end
+    def test_output_of_bookmarked_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:users:1:bookmarked_cars', Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Car, 1)
+    end
 
-  def test_output_of_recommended_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Car, 1), 'recommendable:users:1:recommended_cars'
-  end
+    def test_output_of_recommended_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:users:1:recommended_cars', Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Car, 1)
+    end
 
-  def test_output_of_liked_by_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Car, 1), 'recommendable:cars:1:liked_by'
-  end
+    def test_output_of_liked_by_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:cars:1:liked_by', Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Car, 1)
+    end
 
-  def test_output_of_disliked_by_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Car, 1), 'recommendable:cars:1:disliked_by'
-  end
+    def test_output_of_disliked_by_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:cars:1:disliked_by', Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Car, 1)
+    end
 
-  def test_output_of_score_set_for_ratable_subclass_of_nonratable
-    assert_equal Recommendable::Helpers::RedisKeyMapper.score_set_for(Car), 'recommendable:cars:scores'
+    def test_output_of_score_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable:cars:scores', Recommendable::Helpers::RedisKeyMapper.score_set_for(Car)
+    end
   end
 
+  describe "with proc namespace" do
+    def setup
+      Recommendable::config.redis_namespace = lambda {"recommendable_proc"}
+    end
+
+    def test_output_of_liked_set_for
+      assert_equal 'recommendable_proc:users:1:liked_movies', Recommendable::Helpers::RedisKeyMapper.liked_set_for(Movie, 1)
+    end
+
+    def test_output_of_disliked_set_for
+      assert_equal 'recommendable_proc:users:1:disliked_movies', Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Movie, 1)
+    end
+
+    def test_output_of_hidden_set_for
+      assert_equal 'recommendable_proc:users:1:hidden_movies', Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Movie, 1)
+    end
+
+    def test_output_of_bookmarked_set_for
+      assert_equal 'recommendable_proc:users:1:bookmarked_movies', Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Movie, 1)
+    end
+
+    def test_output_of_recommended_set_for
+      assert_equal 'recommendable_proc:users:1:recommended_movies', Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Movie, 1)
+    end
+
+    def test_output_of_similarity_set_for
+      assert_equal 'recommendable_proc:users:1:similarities', Recommendable::Helpers::RedisKeyMapper.similarity_set_for(1)
+    end
+
+    def test_output_of_liked_by_set_for
+      assert_equal 'recommendable_proc:movies:1:liked_by', Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Movie, 1)
+    end
+
+    def test_output_of_disliked_by_set_for
+      assert_equal 'recommendable_proc:movies:1:disliked_by', Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Movie, 1)
+    end
+
+    def test_output_of_score_set_for
+      assert_equal 'recommendable_proc:movies:scores', Recommendable::Helpers::RedisKeyMapper.score_set_for(Movie)
+    end
+
+    def test_output_of_liked_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:users:1:liked_movies', Recommendable::Helpers::RedisKeyMapper.liked_set_for(Documentary, 1)
+    end
+
+    def test_output_of_disliked_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:users:1:disliked_movies', Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Documentary, 1)
+    end
+
+    def test_output_of_hidden_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:users:1:hidden_movies', Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Documentary, 1)
+    end
+
+    def test_output_of_bookmarked_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:users:1:bookmarked_movies', Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Documentary, 1)
+    end
+
+    def test_output_of_recommended_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:users:1:recommended_movies', Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Documentary, 1)
+    end
+
+    def test_output_of_liked_by_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:movies:1:liked_by', Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Documentary, 1)
+    end
+
+    def test_output_of_disliked_by_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:movies:1:disliked_by', Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Documentary, 1)
+    end
+
+    def test_output_of_score_set_for_subclass_of_ratable
+      assert_equal 'recommendable_proc:movies:scores', Recommendable::Helpers::RedisKeyMapper.score_set_for(Documentary)
+    end
+
+    def test_output_of_liked_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:users:1:liked_cars', Recommendable::Helpers::RedisKeyMapper.liked_set_for(Car, 1)
+    end
+
+    def test_output_of_disliked_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:users:1:disliked_cars', Recommendable::Helpers::RedisKeyMapper.disliked_set_for(Car, 1)
+    end
+
+    def test_output_of_hidden_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:users:1:hidden_cars', Recommendable::Helpers::RedisKeyMapper.hidden_set_for(Car, 1)
+    end
+
+    def test_output_of_bookmarked_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:users:1:bookmarked_cars', Recommendable::Helpers::RedisKeyMapper.bookmarked_set_for(Car, 1)
+    end
+
+    def test_output_of_recommended_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:users:1:recommended_cars', Recommendable::Helpers::RedisKeyMapper.recommended_set_for(Car, 1)
+    end
+
+    def test_output_of_liked_by_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:cars:1:liked_by', Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(Car, 1)
+    end
+
+    def test_output_of_disliked_by_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:cars:1:disliked_by', Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(Car, 1)
+    end
+
+    def test_output_of_score_set_for_ratable_subclass_of_nonratable
+      assert_equal 'recommendable_proc:cars:scores', Recommendable::Helpers::RedisKeyMapper.score_set_for(Car)
+    end
+
+    def teardown
+      Recommendable::config.redis_namespace = :recommendable
+    end
+  end
 end