predictor 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce936c35fc81b3f16b757d6e98a90e0a61c83c36
-  data.tar.gz: 839d3b0b314273ef857fd88a67f3a6e0b8d2c45f
+  metadata.gz: f06d8361ac24ffaedb43dc650bba9af6ad62374a
+  data.tar.gz: c2815b5b8a507026bae58773ac32a1d7188debcb
 SHA512:
-  metadata.gz: 14e5aacf724794effdaf7e6f092e6b19be17b30885aefe2f71d1414607bf243006142346678aac70fecef0b794cc0e14cb80c71f385242b090f2e2f5328d3ec2
-  data.tar.gz: 7f8477ed02993b787b52e74805952f75eb9f45cab316aa4d191e64ffc89dce1f5a66f6c1aa68dea3457c4d5ce2fb85e311b32ea3d53193494138f052e2911f8d
+  metadata.gz: 2988190b65071a5d155974db67bc9815614720f57d9e5131ac429c0fcae5d7210527a07548aca73066a63fee542ee6edb7fb9209304041374df04304e72650ff
+  data.tar.gz: aa8215990ac119de3ca275c9ab666cbe246ffa53f28f5c428361734d7a3a79186bffc007d83056d3b1511beead9ab9ec0aa1f941a97fc8d41378b48b61775b53

data/Changelog.md

@@ -2,6 +2,18 @@
 Predictor Changelog
 =========
 
+2.2.0 (Unreleased)
+---------------------
+* The namespace used for keys in Redis is now configurable on a global or per-class basis. See the readme for more information. If you were overriding the redis_prefix instance method before, it is recommended that you use the new redis_prefix class method instead.
+* Data stored in Redis is now namespaced by the class name of the recommender it is stored by. This change ensures that different recommenders with input matrices of the same name don't overwrite each others' data. After upgrading you'll need to either reindex your data in Redis or configure Predictor to use the naming system you were using before. If you were using the defaults before and you're not worried about matrix name collisions, you can mimic the old behavior with:
+```ruby
+  class MyRecommender
+    include Predictor::Base
+    redis_prefix [nil]
+  end
+```
+* The #predictions_for method on recommenders now accepts a :boost option to give more weight to items with particular attributes. See the readme for more information.
+
 2.1.0 (2014-06-19)
 ---------------------
 * The similarity limit now defaults to 128, instead of being unlimited. This is intended to save space in Redis. See the Readme for more information. It is strongly recommended that you run `ensure_similarity_limit_is_obeyed!` to shrink existing similarity sets.

data/README.md

@@ -172,6 +172,53 @@ You can also use `limit_similarities_to(nil)` to remove the limit entirely. This
 
 If at some point you decide to lower your similarity limits, you'll want to be sure to shrink the size of the sorted sets already in Redis. You can do this with `CourseRecommender.new.ensure_similarity_limit_is_obeyed!`.
 
+Boost
+---------------------
+What if you want to recommend courses to users based not only on what courses they've taken, but on other attributes of courses that they may be interested in? You can do that by passing the :boost argument to predictions_for:
+
+```ruby
+class CourseRecommender
+  include Predictor::Base
+
+  # Courses are compared to one another by the users taking them and their tags.
+  input_matrix :users,  weight: 3.0
+  input_matrix :tags,   weight: 2.0
+  input_matrix :topics, weight: 2.0
+end
+
+recommender = CourseRecommender.new
+
+# We want to find recommendations for Billy, who's told us that he's
+# especially interested in free, interactive courses on Photoshop. So, we give
+# a boost to courses that are tagged as free and interactive and have
+# Photoshop as a topic:
+recommender.predictions_for("Billy", matrix_label: :users, boost: {tags: ['free', 'interactive'], topics: ["Photoshop"]})
+
+# We can also modify how much these tags and topics matter by specifying a
+# weight. The default is 1.0, but if that's too much we can just tweak it:
+recommender.predictions_for("Billy", matrix_label: :users, boost: {tags: {values: ['free', 'interactive'], weight: 0.4}, topics: {values: ["Photoshop"], weight: 0.3}})
+```
+
+Key Prefixes
+---------------------
+As of 2.2.0, there is much more control available over the format of the keys Predictor will use in Redis. By default, the CourseRecommender given as an example above will use keys like "predictor:CourseRecommender:users:items:user1". You can configure the global namespace like so:
+
+```ruby
+  Predictor.redis_prefix 'my_namespace' # => "my_namespace:CourseRecommender:users:items:user1"
+  # Or, for a multitenanted setup:
+  Predictor.redis_prefix { "user-#{User.current.id}" } # => "user-7:CourseRecommender:users:items:user1"
+```
+
+You can also configure the namespace used by each class you create:
+
+```ruby
+  class CourseRecommender
+    include Predictor::Base
+    redis_prefix "courses" # => "predictor:courses:users:items:user1"
+    redis_prefix { "courses_for_user-#{User.current.id}" } # => "predictor:courses_for_user-7:users:items:user1"
+  end
+```
+
 Upgrading from 1.0 to 2.0
 ---------------------
 As mentioned, 2.0.0 is quite a bit different than 1.0.0, so simply upgrading with no changes likely won't work. My apologies for this. I promise this won't happen in future releases, as I'm much more confident in this Predictor release than the last. Anywho, upgrading really shouldn't be that much of a pain if you follow these steps:

data/Rakefile

@@ -1 +1,6 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/predictor/base.rb

@@ -30,17 +30,33 @@ module Predictor::Base
     def input_matrices
       @matrices
     end
+
+    def redis_prefix(prefix = nil, &block)
+      @redis_prefix = block_given? ? block : prefix
+    end
+
+    def get_redis_prefix
+      if @redis_prefix
+        if @redis_prefix.respond_to?(:call)
+          @redis_prefix.call
+        else
+          @redis_prefix
+        end
+      else
+        to_s
+      end
+    end
   end
 
   def input_matrices
     @input_matrices ||= Hash[self.class.input_matrices.map{ |key, opts|
-      opts.merge!(:key => key, :redis_prefix => redis_prefix)
+      opts.merge!(:key => key, :base => self)
       [ key, Predictor::InputMatrix.new(opts) ]
     }]
   end
 
   def redis_prefix
-    "predictor"
+    [Predictor.get_redis_prefix, self.class.get_redis_prefix]
   end
 
   def similarity_limit
@@ -88,7 +104,7 @@ module Predictor::Base
     keys.empty? ? [] : (Predictor.redis.sunion(keys) - [item.to_s])
   end
 
-  def predictions_for(set=nil, item_set: nil, matrix_label: nil, with_scores: false, offset: 0, limit: -1, exclusion_set: [])
+  def predictions_for(set=nil, item_set: nil, matrix_label: nil, with_scores: false, offset: 0, limit: -1, exclusion_set: [], boost: {})
     fail "item_set or matrix_label and set is required" unless item_set || (matrix_label && set)
 
     if matrix_label
@@ -96,16 +112,48 @@ module Predictor::Base
       item_set = Predictor.redis.smembers(matrix.redis_key(:items, set))
     end
 
-    item_keys = item_set.map { |item| redis_key(:similarities, item) }
+    item_keys = []
+    weights   = []
+
+    item_set.each do |item|
+      item_keys << redis_key(:similarities, item)
+      weights   << 1.0
+    end
+
+    boost.each do |matrix_label, values|
+      m = input_matrices[matrix_label]
+
+      # Passing plain sets to zunionstore is undocumented, but tested and supported:
+      # https://github.com/antirez/redis/blob/2.8.11/tests/unit/type/zset.tcl#L481-L489
+
+      case values
+      when Hash
+        values[:values].each do |value|
+          item_keys << m.redis_key(:items, value)
+          weights   << values[:weight]
+        end
+      when Array
+        values.each do |value|
+          item_keys << m.redis_key(:items, value)
+          weights   << 1.0
+        end
+      else
+        raise "Bad value for boost: #{boost.inspect}"
+      end
+    end
+
     return [] if item_keys.empty?
+
     predictions = nil
+
     Predictor.redis.multi do |multi|
-      multi.zunionstore 'temp', item_keys
-      multi.zrem 'temp', item_set
+      multi.zunionstore 'temp', item_keys, weights: weights
+      multi.zrem 'temp', item_set if item_set.any?
       multi.zrem 'temp', exclusion_set if exclusion_set.length > 0
       predictions = multi.zrevrange 'temp', offset, limit == -1 ? limit : offset + (limit - 1), with_scores: with_scores
       multi.del 'temp'
     end
+
     predictions.value
   end
 
@@ -169,7 +217,7 @@ module Predictor::Base
   end
 
   def clean!
-    keys = Predictor.redis.keys("#{self.redis_prefix}:*")
+    keys = Predictor.redis.keys(redis_key('*'))
     unless keys.empty?
       Predictor.redis.del(keys)
     end

data/lib/predictor/input_matrix.rb

@@ -4,12 +4,16 @@ module Predictor
       @opts = opts
     end
 
+    def base
+      @opts[:base]
+    end
+
     def parent_redis_key(*append)
-      ([@opts.fetch(:redis_prefix)] + append).flatten.compact.join(":")
+      base.redis_key(*append)
     end
 
     def redis_key(*append)
-      ([@opts.fetch(:redis_prefix), @opts.fetch(:key)] + append).flatten.compact.join(":")
+      base.redis_key(@opts.fetch(:key), *append)
     end
 
     def weight

data/lib/predictor/predictor.rb

@@ -1,5 +1,6 @@
 module Predictor
   @@redis = nil
+  @@redis_prefix = nil
 
   def self.redis=(redis)
     @@redis = redis
@@ -10,6 +11,22 @@ module Predictor
     raise "redis not configured! - Predictor.redis = Redis.new"
   end
 
+  def self.redis_prefix(prefix = nil, &block)
+    @@redis_prefix = block_given? ? block : prefix
+  end
+
+  def self.get_redis_prefix
+    if @@redis_prefix
+      if @@redis_prefix.respond_to?(:call)
+        @@redis_prefix.call
+      else
+        @@redis_prefix
+      end
+    else
+      'predictor'
+    end
+  end
+
   def self.capitalize(str_or_sym)
   	str = str_or_sym.to_s.each_char.to_a
   	str.first.upcase + str[1..-1].join("").downcase
@@ -18,4 +35,4 @@ module Predictor
   def self.constantize(klass)
     Object.module_eval("Predictor::#{klass}", __FILE__, __LINE__)
   end
-end
+end

data/lib/predictor/version.rb

@@ -1,3 +1,3 @@
 module Predictor
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

data/spec/base_spec.rb

@@ -1,54 +1,135 @@
 require 'spec_helper'
 
 describe Predictor::Base do
-  class BaseRecommender
-    include Predictor::Base
-  end
-
   before(:each) do
     flush_redis!
     BaseRecommender.input_matrices = {}
     BaseRecommender.reset_similarity_limit!
+    BaseRecommender.redis_prefix(nil)
+    UserRecommender.input_matrices = {}
+    UserRecommender.reset_similarity_limit!
   end
 
   describe "configuration" do
     it "should add an input_matrix by 'key'" do
       BaseRecommender.input_matrix(:myinput)
-      BaseRecommender.input_matrices.keys.should == [:myinput]
+      expect(BaseRecommender.input_matrices.keys).to eq([:myinput])
     end
 
     it "should default the similarity_limit to 128" do
-      BaseRecommender.similarity_limit.should == 128
+      expect(BaseRecommender.similarity_limit).to eq(128)
     end
 
     it "should allow the similarity limit to be configured" do
       BaseRecommender.limit_similarities_to(500)
-      BaseRecommender.similarity_limit.should == 500
+      expect(BaseRecommender.similarity_limit).to eq(500)
     end
 
     it "should allow the similarity limit to be removed" do
       BaseRecommender.limit_similarities_to(nil)
-      BaseRecommender.similarity_limit.should == nil
+      expect(BaseRecommender.similarity_limit).to eq(nil)
     end
 
     it "should retrieve an input_matrix on a new instance" do
       BaseRecommender.input_matrix(:myinput)
       sm = BaseRecommender.new
-      lambda{ sm.myinput }.should_not raise_error
+      expect{ sm.myinput }.not_to raise_error
     end
 
     it "should retrieve an input_matrix on a new instance and correctly overload respond_to?" do
       BaseRecommender.input_matrix(:myinput)
       sm = BaseRecommender.new
-      sm.respond_to?(:process!).should be_true
-      sm.respond_to?(:myinput).should be_true
-      sm.respond_to?(:fnord).should be_false
+      expect(sm.respond_to?(:process!)).to be_true
+      expect(sm.respond_to?(:myinput)).to be_true
+      expect(sm.respond_to?(:fnord)).to be_false
     end
 
     it "should retrieve an input_matrix on a new instance and intialize the correct class" do
       BaseRecommender.input_matrix(:myinput)
       sm = BaseRecommender.new
-      sm.myinput.should be_a(Predictor::InputMatrix)
+      expect(sm.myinput).to be_a(Predictor::InputMatrix)
+    end
+  end
+
+  describe "redis_key" do
+    it "should vary based on the class name" do
+      expect(BaseRecommender.new.redis_key).to eq('predictor-test:BaseRecommender')
+      expect(UserRecommender.new.redis_key).to eq('predictor-test:UserRecommender')
+    end
+  end
+
+  describe "redis_key" do
+    it "should vary based on the class name" do
+      expect(BaseRecommender.new.redis_key).to eq('predictor-test:BaseRecommender')
+      expect(UserRecommender.new.redis_key).to eq('predictor-test:UserRecommender')
+    end
+
+    it "should be able to mimic the old naming defaults" do
+      BaseRecommender.redis_prefix([nil])
+      expect(BaseRecommender.new.redis_key(:key)).to eq('predictor-test:key')
+    end
+
+    it "should respect the Predictor prefix configuration setting" do
+      br = BaseRecommender.new
+
+      expect(br.redis_key).to eq("predictor-test:BaseRecommender")
+      expect(br.redis_key(:another)).to eq("predictor-test:BaseRecommender:another")
+      expect(br.redis_key(:another, :key)).to eq("predictor-test:BaseRecommender:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:BaseRecommender:another:set:of:keys")
+
+      i = 0
+      Predictor.redis_prefix { i += 1 }
+      expect(br.redis_key).to eq("1:BaseRecommender")
+      expect(br.redis_key(:another)).to eq("2:BaseRecommender:another")
+      expect(br.redis_key(:another, :key)).to eq("3:BaseRecommender:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("4:BaseRecommender:another:set:of:keys")
+
+      Predictor.redis_prefix nil
+      expect(br.redis_key).to eq("predictor:BaseRecommender")
+      expect(br.redis_key(:another)).to eq("predictor:BaseRecommender:another")
+      expect(br.redis_key(:another, :key)).to eq("predictor:BaseRecommender:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("predictor:BaseRecommender:another:set:of:keys")
+
+      Predictor.redis_prefix [nil]
+      expect(br.redis_key).to eq("BaseRecommender")
+      expect(br.redis_key(:another)).to eq("BaseRecommender:another")
+      expect(br.redis_key(:another, :key)).to eq("BaseRecommender:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("BaseRecommender:another:set:of:keys")
+
+      Predictor.redis_prefix { [1, 2, 3] }
+      expect(br.redis_key).to eq("1:2:3:BaseRecommender")
+      expect(br.redis_key(:another)).to eq("1:2:3:BaseRecommender:another")
+      expect(br.redis_key(:another, :key)).to eq("1:2:3:BaseRecommender:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("1:2:3:BaseRecommender:another:set:of:keys")
+
+      Predictor.redis_prefix 'predictor-test'
+      expect(br.redis_key).to eq("predictor-test:BaseRecommender")
+      expect(br.redis_key(:another)).to eq("predictor-test:BaseRecommender:another")
+      expect(br.redis_key(:another, :key)).to eq("predictor-test:BaseRecommender:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:BaseRecommender:another:set:of:keys")
+    end
+
+    it "should respect the class prefix configuration setting" do
+      br = BaseRecommender.new
+
+      BaseRecommender.redis_prefix('base')
+      expect(br.redis_key).to eq("predictor-test:base")
+      expect(br.redis_key(:another)).to eq("predictor-test:base:another")
+      expect(br.redis_key(:another, :key)).to eq("predictor-test:base:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:base:another:set:of:keys")
+
+      i = 0
+      BaseRecommender.redis_prefix { i += 1 }
+      expect(br.redis_key).to eq("predictor-test:1")
+      expect(br.redis_key(:another)).to eq("predictor-test:2:another")
+      expect(br.redis_key(:another, :key)).to eq("predictor-test:3:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:4:another:set:of:keys")
+
+      BaseRecommender.redis_prefix(nil)
+      expect(br.redis_key).to eq("predictor-test:BaseRecommender")
+      expect(br.redis_key(:another)).to eq("predictor-test:BaseRecommender:another")
+      expect(br.redis_key(:another, :key)).to eq("predictor-test:BaseRecommender:another:key")
+      expect(br.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:BaseRecommender:another:set:of:keys")
     end
   end
 
@@ -59,8 +140,23 @@ describe Predictor::Base do
       sm = BaseRecommender.new
       sm.add_to_matrix(:anotherinput, 'a', "foo", "bar")
       sm.add_to_matrix(:yetanotherinput, 'b', "fnord", "shmoo", "bar")
-      sm.all_items.should include('foo', 'bar', 'fnord', 'shmoo')
-      sm.all_items.length.should == 4
+      expect(sm.all_items).to include('foo', 'bar', 'fnord', 'shmoo')
+      expect(sm.all_items.length).to eq(4)
+    end
+
+    it "doesn't return items from other recommenders" do
+      BaseRecommender.input_matrix(:anotherinput)
+      BaseRecommender.input_matrix(:yetanotherinput)
+      UserRecommender.input_matrix(:anotherinput)
+      UserRecommender.input_matrix(:yetanotherinput)
+      sm = BaseRecommender.new
+      sm.add_to_matrix(:anotherinput, 'a', "foo", "bar")
+      sm.add_to_matrix(:yetanotherinput, 'b', "fnord", "shmoo", "bar")
+      expect(sm.all_items).to include('foo', 'bar', 'fnord', 'shmoo')
+      expect(sm.all_items.length).to eq(4)
+
+      ur = UserRecommender.new
+      expect(ur.all_items).to eq([])
     end
   end
 
@@ -68,7 +164,7 @@ describe Predictor::Base do
     it "calls add_to_set on the given matrix" do
       BaseRecommender.input_matrix(:anotherinput)
       sm = BaseRecommender.new
-      sm.anotherinput.should_receive(:add_to_set).with('a', 'foo', 'bar')
+      expect(sm.anotherinput).to receive(:add_to_set).with('a', 'foo', 'bar')
       sm.add_to_matrix(:anotherinput, 'a', 'foo', 'bar')
     end
 
@@ -76,7 +172,7 @@ describe Predictor::Base do
       BaseRecommender.input_matrix(:anotherinput)
       sm = BaseRecommender.new
       sm.add_to_matrix(:anotherinput, 'a', 'foo', 'bar')
-      sm.all_items.should include('foo', 'bar')
+      expect(sm.all_items).to include('foo', 'bar')
     end
   end
 
@@ -84,8 +180,8 @@ describe Predictor::Base do
     it "calls add_to_matrix and process_items! for the given items" do
       BaseRecommender.input_matrix(:anotherinput)
       sm = BaseRecommender.new
-      sm.should_receive(:add_to_matrix).with(:anotherinput, 'a', 'foo')
-      sm.should_receive(:process_items!).with('foo')
+      expect(sm).to receive(:add_to_matrix).with(:anotherinput, 'a', 'foo')
+      expect(sm).to receive(:process_items!).with('foo')
       sm.add_to_matrix!(:anotherinput, 'a', 'foo')
     end
   end
@@ -100,8 +196,8 @@ describe Predictor::Base do
       sm.yetanotherinput.add_to_set('b', "fnord", "shmoo", "bar")
       sm.finalinput.add_to_set('c', "nada")
       sm.process!
-      sm.related_items("bar").should include("foo", "fnord", "shmoo")
-      sm.related_items("bar").length.should == 3
+      expect(sm.related_items("bar")).to include("foo", "fnord", "shmoo")
+      expect(sm.related_items("bar").length).to eq(3)
     end
   end
 
@@ -119,20 +215,96 @@ describe Predictor::Base do
       sm.tags.add_to_set('tag3', "shmoo", "nada")
       sm.process!
       predictions = sm.predictions_for('me', matrix_label: :users)
-      predictions.should == ["shmoo", "other", "nada"]
+      expect(predictions).to eq(["shmoo", "other", "nada"])
       predictions = sm.predictions_for(item_set: ["foo", "bar", "fnord"])
-      predictions.should == ["shmoo", "other", "nada"]
+      expect(predictions).to eq(["shmoo", "other", "nada"])
       predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, limit: 1)
-      predictions.should == ["other"]
+      expect(predictions).to eq(["other"])
       predictions = sm.predictions_for('me', matrix_label: :users, offset: 1)
-      predictions.should == ["other", "nada"]
+      expect(predictions).to eq(["other", "nada"])
+    end
+
+    it "accepts a :boost option" do
+      BaseRecommender.input_matrix(:users, weight: 4.0)
+      BaseRecommender.input_matrix(:tags, weight: 1.0)
+      sm = BaseRecommender.new
+      sm.users.add_to_set('me', "foo", "bar", "fnord")
+      sm.users.add_to_set('not_me', "foo", "shmoo")
+      sm.users.add_to_set('another', "fnord", "other")
+      sm.users.add_to_set('another', "nada")
+      sm.tags.add_to_set('tag1', "foo", "fnord", "shmoo")
+      sm.tags.add_to_set('tag2', "bar", "shmoo")
+      sm.tags.add_to_set('tag3', "shmoo", "nada")
+      sm.process!
+
+      # Syntax #1: Tags passed as array, weights assumed to be 1.0
+      predictions = sm.predictions_for('me', matrix_label: :users, boost: {tags: ['tag3']})
+      expect(predictions).to eq(["shmoo", "nada", "other"])
+      predictions = sm.predictions_for(item_set: ["foo", "bar", "fnord"], boost: {tags: ['tag3']})
+      expect(predictions).to eq(["shmoo", "nada", "other"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, limit: 1, boost: {tags: ['tag3']})
+      expect(predictions).to eq(["nada"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, boost: {tags: ['tag3']})
+      expect(predictions).to eq(["nada", "other"])
+
+      # Syntax #2: Weights explicitly set.
+      predictions = sm.predictions_for('me', matrix_label: :users, boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["shmoo", "nada", "other"])
+      predictions = sm.predictions_for(item_set: ["foo", "bar", "fnord"], boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["shmoo", "nada", "other"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, limit: 1, boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["nada"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["nada", "other"])
+
+      # Make sure weights are actually being passed to Redis.
+      shmoo, nada, other = sm.predictions_for('me', matrix_label: :users, boost: {tags: {values: ['tag3'], weight: 10000.0}}, with_scores: true)
+      expect(shmoo[0]).to eq('shmoo')
+      expect(shmoo[1]).to be > 10000
+      expect(nada[0]).to eq('nada')
+      expect(nada[1]).to be > 10000
+      expect(other[0]).to eq('other')
+      expect(other[1]).to be < 10
+    end
+
+    it "accepts a :boost option, even with an empty item set" do
+      BaseRecommender.input_matrix(:users, weight: 4.0)
+      BaseRecommender.input_matrix(:tags, weight: 1.0)
+      sm = BaseRecommender.new
+      sm.users.add_to_set('not_me', "foo", "shmoo")
+      sm.users.add_to_set('another', "fnord", "other")
+      sm.users.add_to_set('another', "nada")
+      sm.tags.add_to_set('tag1', "foo", "fnord", "shmoo")
+      sm.tags.add_to_set('tag2', "bar", "shmoo")
+      sm.tags.add_to_set('tag3', "shmoo", "nada")
+      sm.process!
+
+      # Syntax #1: Tags passed as array, weights assumed to be 1.0
+      predictions = sm.predictions_for('me', matrix_label: :users, boost: {tags: ['tag3']})
+      expect(predictions).to eq(["shmoo", "nada"])
+      predictions = sm.predictions_for(item_set: [], boost: {tags: ['tag3']})
+      expect(predictions).to eq(["shmoo", "nada"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, limit: 1, boost: {tags: ['tag3']})
+      expect(predictions).to eq(["nada"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, boost: {tags: ['tag3']})
+      expect(predictions).to eq(["nada"])
+
+      # Syntax #2: Weights explicitly set.
+      predictions = sm.predictions_for('me', matrix_label: :users, boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["shmoo", "nada"])
+      predictions = sm.predictions_for(item_set: [], boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["shmoo", "nada"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, limit: 1, boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["nada"])
+      predictions = sm.predictions_for('me', matrix_label: :users, offset: 1, boost: {tags: {values: ['tag3'], weight: 1.0}})
+      expect(predictions).to eq(["nada"])
     end
   end
 
   describe "similarities_for" do
     it "should not throw exception for non existing items" do
       sm = BaseRecommender.new
-      sm.similarities_for("not_existing_item").length.should == 0
+      expect(sm.similarities_for("not_existing_item").length).to eq(0)
     end
 
     it "correctly weighs and sums input matrices" do
@@ -150,10 +322,10 @@ describe Predictor::Base do
       sm.tags.add_to_set('tag2', "c1", "c4")
 
       sm.process!
-      sm.similarities_for("c1", with_scores: true).should eq([["c4", 6.5], ["c2", 2.0]])
-      sm.similarities_for("c2", with_scores: true).should eq([["c3", 4.0], ["c1", 2.0], ["c4", 1.5]])
-      sm.similarities_for("c3", with_scores: true).should eq([["c2", 4.0], ["c4", 0.5]])
-      sm.similarities_for("c4", with_scores: true, exclusion_set: ["c3"]).should eq([["c1", 6.5], ["c2", 1.5]])
+      expect(sm.similarities_for("c1", with_scores: true)).to eq([["c4", 6.5], ["c2", 2.0]])
+      expect(sm.similarities_for("c2", with_scores: true)).to eq([["c3", 4.0], ["c1", 2.0], ["c4", 1.5]])
+      expect(sm.similarities_for("c3", with_scores: true)).to eq([["c2", 4.0], ["c4", 0.5]])
+      expect(sm.similarities_for("c4", with_scores: true, exclusion_set: ["c3"])).to eq([["c1", 6.5], ["c2", 1.5]])
     end
   end
 
@@ -165,9 +337,9 @@ describe Predictor::Base do
       sm.set1.add_to_set "item1", "foo", "bar"
       sm.set1.add_to_set "item2", "nada", "bar"
       sm.set2.add_to_set "item3", "bar", "other"
-      sm.sets_for("bar").length.should == 3
-      sm.sets_for("bar").should include("item1", "item2", "item3")
-      sm.sets_for("other").should == ["item3"]
+      expect(sm.sets_for("bar").length).to eq(3)
+      expect(sm.sets_for("bar")).to include("item1", "item2", "item3")
+      expect(sm.sets_for("other")).to eq(["item3"])
     end
   end
 
@@ -182,10 +354,10 @@ describe Predictor::Base do
         sm.mysecondinput.add_to_set 'set2', 'item2', 'item3'
         sm.mythirdinput.add_to_set 'set3', 'item2', 'item3'
         sm.mythirdinput.add_to_set 'set4', 'item1', 'item2', 'item3'
-        sm.similarities_for('item2').should be_empty
+        expect(sm.similarities_for('item2')).to be_empty
         sm.process_items!('item2')
         similarities = sm.similarities_for('item2', with_scores: true)
-        similarities.should include(["item3", 4.0], ["item1", 2.5])
+        expect(similarities).to include(["item3", 4.0], ["item1", 2.5])
       end
     end
 
@@ -200,11 +372,11 @@ describe Predictor::Base do
         sm.mysecondinput.add_to_set 'set2', 'item2', 'item3'
         sm.mythirdinput.add_to_set 'set3', 'item2', 'item3'
         sm.mythirdinput.add_to_set 'set4', 'item1', 'item2', 'item3'
-        sm.similarities_for('item2').should be_empty
+        expect(sm.similarities_for('item2')).to be_empty
         sm.process_items!('item2')
         similarities = sm.similarities_for('item2', with_scores: true)
-        similarities.should include(["item3", 4.0])
-        similarities.length.should == 1
+        expect(similarities).to include(["item3", 4.0])
+        expect(similarities.length).to eq(1)
       end
     end
   end
@@ -216,8 +388,8 @@ describe Predictor::Base do
       sm = BaseRecommender.new
       sm.anotherinput.add_to_set('a', "foo", "bar")
       sm.yetanotherinput.add_to_set('b', "fnord", "shmoo")
-      sm.all_items.should include("foo", "bar", "fnord", "shmoo")
-      sm.should_receive(:process_items!).with(*sm.all_items)
+      expect(sm.all_items).to include("foo", "bar", "fnord", "shmoo")
+      expect(sm).to receive(:process_items!).with(*sm.all_items)
       sm.process!
     end
   end
@@ -230,8 +402,8 @@ describe Predictor::Base do
       sm.anotherinput.add_to_set('a', "foo", "bar")
       sm.yetanotherinput.add_to_set('b', "bar", "shmoo")
       sm.process!
-      sm.similarities_for('bar').should include('foo', 'shmoo')
-      sm.anotherinput.should_receive(:delete_item).with('foo')
+      expect(sm.similarities_for('bar')).to include('foo', 'shmoo')
+      expect(sm.anotherinput).to receive(:delete_item).with('foo')
       sm.delete_from_matrix!(:anotherinput, 'foo')
     end
 
@@ -242,9 +414,9 @@ describe Predictor::Base do
       sm.anotherinput.add_to_set('a', "foo", "bar")
       sm.yetanotherinput.add_to_set('b', "bar", "shmoo")
       sm.process!
-      sm.similarities_for('bar').should include('foo', 'shmoo')
+      expect(sm.similarities_for('bar')).to include('foo', 'shmoo')
       sm.delete_from_matrix!(:anotherinput, 'foo')
-      sm.similarities_for('bar').should == ['shmoo']
+      expect(sm.similarities_for('bar')).to eq(['shmoo'])
     end
   end
 
@@ -253,8 +425,8 @@ describe Predictor::Base do
       BaseRecommender.input_matrix(:myfirstinput)
       BaseRecommender.input_matrix(:mysecondinput)
       sm = BaseRecommender.new
-      sm.myfirstinput.should_receive(:delete_item).with("fnorditem")
-      sm.mysecondinput.should_receive(:delete_item).with("fnorditem")
+      expect(sm.myfirstinput).to receive(:delete_item).with("fnorditem")
+      expect(sm.mysecondinput).to receive(:delete_item).with("fnorditem")
       sm.delete_item!("fnorditem")
     end
 
@@ -263,9 +435,9 @@ describe Predictor::Base do
       sm = BaseRecommender.new
       sm.anotherinput.add_to_set('a', "foo", "bar")
       sm.process!
-      sm.all_items.should include('foo')
+      expect(sm.all_items).to include('foo')
       sm.delete_item!('foo')
-      sm.all_items.should_not include('foo')
+      expect(sm.all_items).not_to include('foo')
     end
 
     it "should remove the item's similarities and also remove the item from related_items' similarities" do
@@ -275,11 +447,11 @@ describe Predictor::Base do
       sm.anotherinput.add_to_set('a', "foo", "bar")
       sm.yetanotherinput.add_to_set('b', "bar", "shmoo")
       sm.process!
-      sm.similarities_for('bar').should include('foo', 'shmoo')
-      sm.similarities_for('shmoo').should include('bar')
+      expect(sm.similarities_for('bar')).to include('foo', 'shmoo')
+      expect(sm.similarities_for('shmoo')).to include('bar')
       sm.delete_item!('shmoo')
-      sm.similarities_for('bar').should_not include('shmoo')
-      sm.similarities_for('shmoo').should be_empty
+      expect(sm.similarities_for('bar')).not_to include('shmoo')
+      expect(sm.similarities_for('shmoo')).to be_empty
     end
   end
 
@@ -291,9 +463,10 @@ describe Predictor::Base do
       sm.set1.add_to_set "item1", "foo", "bar"
       sm.set1.add_to_set "item2", "nada", "bar"
       sm.set2.add_to_set "item3", "bar", "other"
-      Predictor.redis.keys("#{sm.redis_prefix}:*").should_not be_empty
+
+      expect(Predictor.redis.keys(sm.redis_key('*'))).not_to be_empty
       sm.clean!
-      Predictor.redis.keys("#{sm.redis_prefix}:*").should be_empty
+      expect(Predictor.redis.keys(sm.redis_key('*'))).to be_empty
     end
   end
 
@@ -304,20 +477,20 @@ describe Predictor::Base do
       BaseRecommender.input_matrix(:myfirstinput)
       sm = BaseRecommender.new
       sm.myfirstinput.add_to_set *(['set1'] + 130.times.map{|i| "item#{i}"})
-      sm.similarities_for('item2').should be_empty
+      expect(sm.similarities_for('item2')).to be_empty
       sm.process_items!('item2')
-      sm.similarities_for('item2').length.should == 129
+      expect(sm.similarities_for('item2').length).to eq(129)
 
       redis = Predictor.redis
       key = sm.redis_key(:similarities, 'item2')
-      redis.zcard(key).should == 129
-      redis.object(:encoding, key).should == 'skiplist' # Inefficient
+      expect(redis.zcard(key)).to eq(129)
+      expect(redis.object(:encoding, key)).to eq('skiplist') # Inefficient
 
       BaseRecommender.reset_similarity_limit!
       sm.ensure_similarity_limit_is_obeyed!
 
-      redis.zcard(key).should == 128
-      redis.object(:encoding, key).should == 'ziplist' # Efficient
+      expect(redis.zcard(key)).to eq(128)
+      expect(redis.object(:encoding, key)).to eq('ziplist') # Efficient
     end
   end
 end

data/spec/input_matrix_spec.rb

@@ -6,7 +6,8 @@ describe Predictor::InputMatrix do
   before(:each) { @options = {} }
 
   before(:all) do
-    @default_options = { redis_prefix: "predictor-test", key: "mymatrix" }
+    @base = BaseRecommender.new
+    @default_options = { base: @base, key: "mymatrix" }
     @matrix = Predictor::InputMatrix.new(@default_options)
   end
 
@@ -14,45 +15,96 @@ describe Predictor::InputMatrix do
     flush_redis!
   end
 
-  it "should build the correct keys" do
-    @matrix.redis_key.should == "predictor-test:mymatrix"
+  describe "redis_key" do
+    it "should respect the global namespace configuration" do
+      expect(@matrix.redis_key).to eq("predictor-test:BaseRecommender:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("predictor-test:BaseRecommender:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("predictor-test:BaseRecommender:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:BaseRecommender:mymatrix:another:set:of:keys")
+
+      i = 0
+      Predictor.redis_prefix { i += 1 }
+      expect(@matrix.redis_key).to eq("1:BaseRecommender:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("2:BaseRecommender:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("3:BaseRecommender:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("4:BaseRecommender:mymatrix:another:set:of:keys")
+
+      Predictor.redis_prefix(nil)
+      expect(@matrix.redis_key).to eq("predictor:BaseRecommender:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("predictor:BaseRecommender:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("predictor:BaseRecommender:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("predictor:BaseRecommender:mymatrix:another:set:of:keys")
+
+      Predictor.redis_prefix('predictor-test')
+      expect(@matrix.redis_key).to eq("predictor-test:BaseRecommender:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("predictor-test:BaseRecommender:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("predictor-test:BaseRecommender:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:BaseRecommender:mymatrix:another:set:of:keys")
+    end
+
+    it "should respect the class-level configuration" do
+      i = 0
+      BaseRecommender.redis_prefix { i += 1 }
+      expect(@matrix.redis_key).to eq("predictor-test:1:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("predictor-test:2:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("predictor-test:3:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:4:mymatrix:another:set:of:keys")
+
+      BaseRecommender.redis_prefix([nil])
+      expect(@matrix.redis_key).to eq("predictor-test:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("predictor-test:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("predictor-test:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:mymatrix:another:set:of:keys")
+
+      BaseRecommender.redis_prefix(['a', 'b'])
+      expect(@matrix.redis_key).to eq("predictor-test:a:b:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("predictor-test:a:b:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("predictor-test:a:b:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:a:b:mymatrix:another:set:of:keys")
+
+      BaseRecommender.redis_prefix(nil)
+      expect(@matrix.redis_key).to eq("predictor-test:BaseRecommender:mymatrix")
+      expect(@matrix.redis_key(:another)).to eq("predictor-test:BaseRecommender:mymatrix:another")
+      expect(@matrix.redis_key(:another, :key)).to eq("predictor-test:BaseRecommender:mymatrix:another:key")
+      expect(@matrix.redis_key(:another, [:set, :of, :keys])).to eq("predictor-test:BaseRecommender:mymatrix:another:set:of:keys")
+    end
   end
 
   describe "weight" do
     it "returns the weight configured or a default of 1" do
-      @matrix.weight.should == 1.0  # default weight
+      expect(@matrix.weight).to eq(1.0)  # default weight
       matrix = Predictor::InputMatrix.new(redis_prefix: "predictor-test", key: "mymatrix", weight: 5.0)
-      matrix.weight.should == 5.0
+      expect(matrix.weight).to eq(5.0)
     end
   end
 
   describe "add_to_set" do
     it "adds each member of the set to the key's 'sets' set" do
-      @matrix.items_for("item1").should_not include("foo", "bar", "fnord", "blubb")
+      expect(@matrix.items_for("item1")).not_to include("foo", "bar", "fnord", "blubb")
       @matrix.add_to_set "item1", "foo", "bar", "fnord", "blubb"
-      @matrix.items_for("item1").should include("foo", "bar", "fnord", "blubb")
+      expect(@matrix.items_for("item1")).to include("foo", "bar", "fnord", "blubb")
     end
 
     it "adds the key to each set member's 'items' set" do
-      @matrix.sets_for("foo").should_not include("item1")
-      @matrix.sets_for("bar").should_not include("item1")
-      @matrix.sets_for("fnord").should_not include("item1")
-      @matrix.sets_for("blubb").should_not include("item1")
+      expect(@matrix.sets_for("foo")).not_to include("item1")
+      expect(@matrix.sets_for("bar")).not_to include("item1")
+      expect(@matrix.sets_for("fnord")).not_to include("item1")
+      expect(@matrix.sets_for("blubb")).not_to include("item1")
       @matrix.add_to_set "item1", "foo", "bar", "fnord", "blubb"
-      @matrix.sets_for("foo").should include("item1")
-      @matrix.sets_for("bar").should include("item1")
-      @matrix.sets_for("fnord").should include("item1")
-      @matrix.sets_for("blubb").should include("item1")
+      expect(@matrix.sets_for("foo")).to include("item1")
+      expect(@matrix.sets_for("bar")).to include("item1")
+      expect(@matrix.sets_for("fnord")).to include("item1")
+      expect(@matrix.sets_for("blubb")).to include("item1")
     end
   end
 
   describe "items_for" do
     it "returns the items in the given set ID" do
       @matrix.add_to_set "item1", ["foo", "bar", "fnord", "blubb"]
-      @matrix.items_for("item1").should include("foo", "bar", "fnord", "blubb")
+      expect(@matrix.items_for("item1")).to include("foo", "bar", "fnord", "blubb")
       @matrix.add_to_set "item2", ["foo", "bar", "snafu", "nada"]
-      @matrix.items_for("item2").should include("foo", "bar", "snafu", "nada")
-      @matrix.items_for("item1").should_not include("snafu", "nada")
+      expect(@matrix.items_for("item2")).to include("foo", "bar", "snafu", "nada")
+      expect(@matrix.items_for("item1")).not_to include("snafu", "nada")
     end
   end
 
@@ -60,8 +112,8 @@ describe Predictor::InputMatrix do
     it "returns the set IDs the given item is in" do
       @matrix.add_to_set "item1", ["foo", "bar", "fnord", "blubb"]
       @matrix.add_to_set "item2", ["foo", "bar", "snafu", "nada"]
-      @matrix.sets_for("foo").should include("item1", "item2")
-      @matrix.sets_for("snafu").should == ["item2"]
+      expect(@matrix.sets_for("foo")).to include("item1", "item2")
+      expect(@matrix.sets_for("snafu")).to eq(["item2"])
     end
   end
 
@@ -70,11 +122,11 @@ describe Predictor::InputMatrix do
       @matrix.add_to_set "item1", ["foo", "bar", "fnord", "blubb"]
       @matrix.add_to_set "item2", ["foo", "bar", "snafu", "nada"]
       @matrix.add_to_set "item3", ["nada", "other"]
-      @matrix.related_items("bar").should include("foo", "fnord", "blubb", "snafu", "nada")
-      @matrix.related_items("bar").length.should == 5
-      @matrix.related_items("other").should == ["nada"]
-      @matrix.related_items("snafu").should include("foo", "bar", "nada")
-      @matrix.related_items("snafu").length.should == 3
+      expect(@matrix.related_items("bar")).to include("foo", "fnord", "blubb", "snafu", "nada")
+      expect(@matrix.related_items("bar").length).to eq(5)
+      expect(@matrix.related_items("other")).to eq(["nada"])
+      expect(@matrix.related_items("snafu")).to include("foo", "bar", "nada")
+      expect(@matrix.related_items("snafu").length).to eq(3)
     end
   end
 
@@ -86,13 +138,13 @@ describe Predictor::InputMatrix do
     end
 
     it "should delete the item from sets it is in" do
-      @matrix.items_for("item1").should include("bar")
-      @matrix.items_for("item2").should include("bar")
-      @matrix.sets_for("bar").should include("item1", "item2")
+      expect(@matrix.items_for("item1")).to include("bar")
+      expect(@matrix.items_for("item2")).to include("bar")
+      expect(@matrix.sets_for("bar")).to include("item1", "item2")
       @matrix.delete_item("bar")
-      @matrix.items_for("item1").should_not include("bar")
-      @matrix.items_for("item2").should_not include("bar")
-      @matrix.sets_for("bar").should be_empty
+      expect(@matrix.items_for("item1")).not_to include("bar")
+      expect(@matrix.items_for("item2")).not_to include("bar")
+      expect(@matrix.sets_for("bar")).to be_empty
     end
   end
 
@@ -105,7 +157,7 @@ describe Predictor::InputMatrix do
         matrix.add_to_set "item2", "bar", "fnord", "shmoo", "snafu"
         matrix.add_to_set "item3", "bar", "nada", "snafu"
 
-        matrix.score("bar", "snafu").should == 2.0/3.0
+        expect(matrix.score("bar", "snafu")).to eq(2.0/3.0)
       end
 
       it "scores as jaccard index when given option" do
@@ -114,13 +166,13 @@ describe Predictor::InputMatrix do
         matrix.add_to_set "item2", "bar", "fnord", "shmoo", "snafu"
         matrix.add_to_set "item3", "bar", "nada", "snafu"
 
-        matrix.score("bar", "snafu").should == 2.0/3.0
+        expect(matrix.score("bar", "snafu")).to eq(2.0/3.0)
       end
 
       it "should handle missing sets" do
         matrix.add_to_set "item1", "foo", "bar", "fnord", "blubb"
 
-        matrix.score("is", "missing").should == 0.0
+        expect(matrix.score("is", "missing")).to eq(0.0)
       end
     end
 
@@ -132,13 +184,13 @@ describe Predictor::InputMatrix do
         matrix.add_to_set "item2", "fnord", "shmoo", "snafu"
         matrix.add_to_set "item3", "bar", "nada", "snafu"
 
-        matrix.score("bar", "snafu").should == 2.0/4.0
+        expect(matrix.score("bar", "snafu")).to eq(2.0/4.0)
       end
 
       it "should handle missing sets" do
         matrix.add_to_set "item1", "foo", "bar", "fnord", "blubb"
 
-        matrix.score("is", "missing").should == 0.0
+        expect(matrix.score("is", "missing")).to eq(0.0)
       end
     end
   end

data/spec/predictor_spec.rb

@@ -4,12 +4,12 @@ describe Predictor do
 
   it "should store a redis connection" do
     Predictor.redis = "asd"
-    Predictor.redis.should == "asd"
+    expect(Predictor.redis).to eq("asd")
   end
 
   it "should raise an exception if unconfigured redis connection is accessed" do
     Predictor.redis = nil
-    lambda{ Predictor.redis }.should raise_error(/not configured/i)
+    expect{ Predictor.redis }.to raise_error(/not configured/i)
   end
 
 end

data/spec/spec_helper.rb

@@ -8,12 +8,14 @@ def flush_redis!
   end
 end
 
-module Predictor::Base
+Predictor.redis_prefix "predictor-test"
 
-  def redis_prefix
-    "predictor-test"
-  end
+class BaseRecommender
+  include Predictor::Base
+end
 
+class UserRecommender
+  include Predictor::Base
 end
 
 class TestRecommender
@@ -23,7 +25,6 @@ class TestRecommender
 end
 
 class Predictor::TestInputMatrix
-
   def initialize(opts)
     @opts = opts
   end
@@ -31,5 +32,4 @@ class Predictor::TestInputMatrix
   def method_missing(method, *args)
     @opts[method]
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: predictor
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Pathgather
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-19 00:00:00.000000000 Z
+date: 2014-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis