recommendify_whosv 0.5.8

data/lib/recommendify/similarity_matrix.rb

@@ -0,0 +1,63 @@
+class Recommendify::SimilarityMatrix
+
+  attr_reader :write_queue
+
+  def initialize(opts={})
+    @opts = opts
+    @write_queue = Hash.new{ |h,k| h[k] = {} }
+  end
+
+  def redis_key(append=nil)
+    [@opts.fetch(:redis_prefix), @opts.fetch(:key), append].flatten.compact.join(":")
+  end
+
+  def max_neighbors
+    @opts[:max_neighbors] || Recommendify::DEFAULT_MAX_NEIGHBORS
+  end
+
+  def update(item_id, neighbors)
+    neighbors.each do |neighbor_id, score|
+      if @write_queue[item_id].has_key?(neighbor_id)
+        @write_queue[item_id][neighbor_id] += score
+      else
+        @write_queue[item_id][neighbor_id] = score
+      end
+    end
+  end
+
+  def [](item_id)
+    if @write_queue.has_key?(item_id)
+      @write_queue[item_id]
+    else
+      retrieve_item(item_id)
+    end
+  end
+
+  def commit_item!(item_id)
+    serialized = serialize_item(item_id)
+    Recommendify.redis.hset(redis_key, item_id, serialized)
+    @write_queue.delete(item_id)    
+  end
+
+  # optimize: the items are already stored in a sorted fashion. we shouldn't 
+  # throw away this info by storing them in a hash (and re-sorting later). maybe 
+  # use activesupport's orderedhash?
+  def retrieve_item(item_id)
+    data = Recommendify.redis.hget(redis_key, item_id)
+    return {} if data.nil?
+    Hash[data.split("|").map{ |i| (k,s=i.split(":")) && [k,s.to_f] }]
+  end
+
+private
+
+  # optimize: implement a better sort. never add more than 50 items the the array
+  def serialize_item(item_id, max_precision=5)
+    items = @write_queue[item_id].to_a
+    items.sort!{ |a,b| b[1] <=> a[1] }
+    #items = items[0..max_neighbors-1]
+    #items = items.map{ |i,s| s>0 ? "#{i}:#{s.to_s[0..max_precision]}" : nil } 
+    items = items.map{ |i,s| "#{i}:#{s.to_s[0..max_precision]}" } 
+    items.compact * "|"
+  end
+
+end

data/lib/recommendify/sparse_matrix.rb

@@ -0,0 +1,53 @@
+class Recommendify::SparseMatrix
+
+  def initialize(opts={})
+    @opts = opts
+  end
+
+  def redis_key
+    [@opts.fetch(:redis_prefix), @opts.fetch(:key)].join(":")
+  end
+
+  def [](x,y)
+    k_get(key(x,y))
+  end
+
+  def []=(x,y,v)
+    v == 0 ? k_del(key(x,y)) : k_set(key(x,y), v)
+  end
+
+  def incr(x,y)
+    k_incr(key(x,y))
+  end
+
+private
+
+  def key(x,y)
+    [x,y].sort.join(":")
+  end
+
+  def k_set(key, val)
+    Recommendify.redis.hset(redis_key, key, val)
+  end
+
+  def k_del(key)
+    Recommendify.redis.hdel(redis_key, key)
+  end
+
+  def k_get(key)
+    Recommendify.redis.hget(redis_key, key).to_f
+  end
+
+  def k_incr(key)
+    Recommendify.redis.hincrby(redis_key, key, 1)
+  end
+
+  # OPTIMIZE: use scripting/lua in redis 2.6
+  def k_delall(*keys)
+    Recommendify.redis.hkeys(redis_key).each do |iikey|
+      next unless (iikey.split(":") & keys).size > 0
+      Recommendify.redis.hdel(redis_key, iikey)
+    end
+  end
+
+end

data/lib/recommendify.rb

@@ -0,0 +1,9 @@
+require "recommendify/recommendify"
+require "recommendify/sparse_matrix"
+require "recommendify/cc_matrix"
+require "recommendify/similarity_matrix"
+require "recommendify/input_matrix"
+require "recommendify/jaccard_input_matrix"
+require "recommendify/cosine_input_matrix"
+require "recommendify/base"
+require "recommendify/neighbor"

data/recommendify.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "recommendify_whosv"
+  s.version     = "0.5.8"
+  s.date        = Date.today.to_s
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Paul Asmuth"]
+  s.email       = ["paul@paulasmuth.com"]
+  s.homepage    = "http://github.com/paulasmuth/recommendify"
+  s.summary     = %q{ruby/redis based recommendation engine (collaborative filtering)}
+  s.description = %q{Recommendify is a distributed, incremental item-based recommendation engine for binary input ratings. It's based on ruby and redis and uses an approach called "Collaborative Filtering"}
+  s.licenses    = ["MIT"]
+
+  s.extensions = ['ext/extconf.rb']
+
+  s.add_dependency "redis", ">= 2.2.2"
+
+  s.add_development_dependency "rspec", "~> 2.8.0"
+
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rspec", ".travis.yml"]
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/spec/base_spec.rb

@@ -0,0 +1,188 @@
+require ::File.expand_path('../spec_helper', __FILE__)
+
+describe Recommendify::Base do
+
+  before(:each) do
+    flush_redis!
+    Recommendify::Base.send(:class_variable_set, :@@max_neighbors, nil)
+    Recommendify::Base.send(:class_variable_set, :@@input_matrices, {})
+  end
+
+  describe "configuration" do
+
+    it "should return default max_neighbors if not configured" do
+      Recommendify::DEFAULT_MAX_NEIGHBORS.should == 50      
+      sm = Recommendify::Base.new
+      sm.max_neighbors.should == 50
+    end
+      
+    it "should remember max_neighbors if configured" do
+      Recommendify::Base.max_neighbors(23)
+      sm = Recommendify::Base.new      
+      sm.max_neighbors.should == 23
+    end
+
+    it "should add an input_matrix by 'key'" do
+      Recommendify::Base.input_matrix(:myinput, :similarity_func => :jaccard)
+      Recommendify::Base.send(:class_variable_get, :@@input_matrices).keys.should == [:myinput]
+    end
+
+    it "should retrieve an input_matrix on a new instance" do
+      Recommendify::Base.input_matrix(:myinput, :similarity_func => :jaccard)
+      sm = Recommendify::Base.new
+      lambda{ sm.myinput }.should_not raise_error
+    end
+
+    it "should retrieve an input_matrix on a new instance and correctly overload respond_to?" do
+      Recommendify::Base.input_matrix(:myinput, :similarity_func => :jaccard)
+      sm = Recommendify::Base.new
+      sm.respond_to?(:process!).should be_true
+      sm.respond_to?(:myinput).should be_true
+      sm.respond_to?(:fnord).should be_false
+    end
+
+    it "should retrieve an input_matrix on a new instance and intialize the correct class" do
+      Recommendify::Base.input_matrix(:myinput, :similarity_func => :jaccard)
+      sm = Recommendify::Base.new
+      sm.myinput.should be_a(Recommendify::JaccardInputMatrix)
+    end
+
+  end
+
+  describe "process_item!" do
+
+    it "should call similarities_for on each input_matrix" do
+      Recommendify::Base.input_matrix(:myfirstinput, :similarity_func => :jaccard)
+      Recommendify::Base.input_matrix(:mysecondinput, :similarity_func => :jaccard)
+      sm = Recommendify::Base.new
+      sm.myfirstinput.should_receive(:similarities_for).with("fnorditem").and_return([["fooitem",0.5]])
+      sm.mysecondinput.should_receive(:similarities_for).with("fnorditem").and_return([["fooitem",0.5]])
+      sm.similarity_matrix.stub!(:update)
+      sm.process_item!("fnorditem")
+    end
+
+    it "should call similarities_for on each input_matrix and add all outputs to the similarity matrix" do
+      Recommendify::Base.input_matrix(:myfirstinput, :similarity_func => :jaccard)
+      Recommendify::Base.input_matrix(:mysecondinput, :similarity_func => :jaccard)
+      sm = Recommendify::Base.new
+      sm.myfirstinput.should_receive(:similarities_for).and_return([["fooitem",0.5]])      
+      sm.mysecondinput.should_receive(:similarities_for).and_return([["fooitem",0.75], ["baritem", 1.0]])
+      sm.similarity_matrix.should_receive(:update).with("fnorditem", [["fooitem",0.5]])
+      sm.similarity_matrix.should_receive(:update).with("fnorditem", [["fooitem",0.75], ["baritem", 1.0]])
+      sm.process_item!("fnorditem")
+    end
+
+    it "should call similarities_for on each input_matrix and add all outputs to the similarity matrix with weight" do
+      Recommendify::Base.input_matrix(:myfirstinput, :similarity_func => :jaccard, :weight => 4.0)
+      Recommendify::Base.input_matrix(:mysecondinput, :similarity_func => :jaccard)
+      sm = Recommendify::Base.new
+      sm.myfirstinput.should_receive(:similarities_for).and_return([["fooitem",0.5]])      
+      sm.mysecondinput.should_receive(:similarities_for).and_return([["fooitem",0.75], ["baritem", 1.0]])
+      sm.similarity_matrix.should_receive(:update).with("fnorditem", [["fooitem",2.0]])
+      sm.similarity_matrix.should_receive(:update).with("fnorditem", [["fooitem",0.75], ["baritem", 1.0]])
+      sm.process_item!("fnorditem")
+    end
+
+    it "should retrieve all items from all input matrices" do
+      Recommendify::Base.input_matrix(:anotherinput, :similarity_func => :test, :all_items => ["foo", "bar"])
+      Recommendify::Base.input_matrix(:yetanotherinput, :similarity_func => :test, :all_items => ["fnord", "shmoo"])
+      sm = Recommendify::Base.new    
+      sm.all_items.length.should == 4
+      sm.all_items.should include("foo")
+      sm.all_items.should include("bar")
+      sm.all_items.should include("fnord")
+      sm.all_items.should include("shmoo")
+    end
+
+    it "should retrieve all items from all input matrices (uniquely)" do
+      Recommendify::Base.input_matrix(:anotherinput, :similarity_func => :test, :all_items => ["foo", "bar"])
+      Recommendify::Base.input_matrix(:yetanotherinput, :similarity_func => :test, :all_items => ["fnord", "bar"])
+      sm = Recommendify::Base.new    
+      sm.all_items.length.should == 3
+      sm.all_items.should include("foo")
+      sm.all_items.should include("bar")
+      sm.all_items.should include("fnord")
+    end
+
+  end
+
+  describe "process!" do
+
+    it "should call process_item for all input_matrix.all_items's" do
+      Recommendify::Base.input_matrix(:anotherinput, :similarity_func => :test, :all_items => ["foo", "bar"])
+      Recommendify::Base.input_matrix(:yetanotherinput, :similarity_func => :test, :all_items => ["fnord", "shmoo"])
+      sm = Recommendify::Base.new    
+      sm.should_receive(:process_item!).exactly(4).times
+      sm.process!
+    end
+
+    it "should call process_item for all input_matrix.all_items's (uniquely)" do
+      Recommendify::Base.input_matrix(:anotherinput, :similarity_func => :test, :all_items => ["foo", "bar"])
+      Recommendify::Base.input_matrix(:yetanotherinput, :similarity_func => :test, :all_items => ["fnord", "bar"])
+      sm = Recommendify::Base.new    
+      sm.should_receive(:process_item!).exactly(3).times
+      sm.process!
+    end
+
+  end
+
+  describe "for(item_id)" do
+
+    it "should retrieve the n-most similar neighbors" do
+      sm = Recommendify::Base.new
+      sm.similarity_matrix.should_receive(:[]).with("fnorditem").and_return({:fooitem => 0.4, :baritem => 1.5})
+      sm.for("fnorditem").length.should == 2
+    end
+    
+    it "should not throw exception for non existing items" do
+      sm = Recommendify::Base.new
+      sm.for("not_existing_item").length.should == 0
+    end
+
+    it "should retrieve the n-most similar neighbors as Recommendify::Neighbor objects" do
+      sm = Recommendify::Base.new
+      sm.similarity_matrix.should_receive(:[]).exactly(2).times.with("fnorditem").and_return({:fooitem => 0.4, :baritem => 1.5})
+      sm.for("fnorditem").first.should be_a(Recommendify::Neighbor)
+      sm.for("fnorditem").last.should be_a(Recommendify::Neighbor)
+    end
+
+    it "should retrieve the n-most similar neighbors in the correct order" do
+      sm = Recommendify::Base.new
+      sm.similarity_matrix.should_receive(:[]).exactly(4).times.with("fnorditem").and_return({:fooitem => 0.4, :baritem => 1.5})
+      sm.for("fnorditem").first.similarity.should == 1.5
+      sm.for("fnorditem").first.item_id.should == "baritem"
+      sm.for("fnorditem").last.similarity.should == 0.4
+      sm.for("fnorditem").last.item_id.should == "fooitem"
+    end
+
+    it "should return an empty array if the item if no neighbors were found" do
+      sm = Recommendify::Base.new
+      sm.similarity_matrix.should_receive(:[]).with("fnorditem").and_return({})
+      sm.for("fnorditem").should == []
+    end
+
+    it "should not call split on nil when retrieving a non-existent item (return an empty array)" do
+      sm = Recommendify::Base.new
+      sm.for("NONEXISTENT").should == []
+    end
+
+  end
+
+  describe "delete_item!" do
+
+    it "should call delete_item on each input_matrix" do
+      Recommendify::Base.input_matrix(:myfirstinput, :similarity_func => :jaccard)
+      Recommendify::Base.input_matrix(:mysecondinput, :similarity_func => :jaccard)
+      sm = Recommendify::Base.new
+      sm.myfirstinput.should_receive(:delete_item).with("fnorditem")
+      sm.mysecondinput.should_receive(:delete_item).with("fnorditem")
+      sm.delete_item!("fnorditem")
+    end
+
+    it "should delete the item from the similarity matrix"
+
+    it "should delete all occurences of the item in other similarity sets from the similarity matrix"
+
+  end
+
+end

data/spec/cc_matrix_shared.rb

@@ -0,0 +1,89 @@
+share_examples_for Recommendify::CCMatrix do
+
+  it "should build a sparsematrix with the correct key" do
+    @matrix.ccmatrix.redis_key.should == "recommendify-test:mymatrix:ccmatrix"
+  end
+
+  it "should increment all item counts on set addition" do
+    Recommendify.redis.hset("recommendify-test:mymatrix:items", "bar", 2)
+    @matrix.add_set("user123", ["foo", "bar"])
+    Recommendify.redis.hget("recommendify-test:mymatrix:items", "bar").to_i.should == 3
+    Recommendify.redis.hget("recommendify-test:mymatrix:items", "foo").to_i.should == 1
+  end
+
+  it "should increment all item<->item pairs on set addition" do
+    @matrix.ccmatrix["bar", "foo"] = 2
+    res = @matrix.add_set("user123", ["foo", "bar", "fnord"])
+    res.length.should == 3
+    @matrix.ccmatrix["bar", "foo"].should == 3
+    @matrix.ccmatrix["foo", "fnord"].should == 1    
+  end
+
+  it "should increment all item<->item paris on single item addition" do
+    @matrix.ccmatrix["bar", "fnord"] = 2
+    @matrix.add_single("user123", "fnord", ["foo", "bar"])
+    @matrix.ccmatrix["bar", "fnord"].should == 3
+    @matrix.ccmatrix["foo", "fnord"].should == 1   
+  end
+
+  it "should increment the item count on single item addition" do
+    @matrix.send(:item_count_incr, "fnordfnord")
+    @matrix.send(:item_count_incr, "fnordfnord")
+    @matrix.send(:item_count_incr, "foofnord")
+    @matrix.add_single("user123", "fnordfnord", ["foofnord", "barfnord"])
+    @matrix.send(:item_count, "foofnord").should == 1
+    @matrix.send(:item_count, "barfnord").should == 0
+    @matrix.send(:item_count, "fnordfnord").should == 3
+  end
+
+  it "should calculate all item<->item pairs (3)" do
+    res = @matrix.send(:all_pairs, ["foo", "bar", "fnord"])
+    res.length.should == 3
+    res.should include("bar:foo")
+    res.should include("fnord:foo")
+    res.should include("bar:fnord")
+  end
+
+  it "should calculate all item<->item pairs (6)" do
+    res = @matrix.send(:all_pairs, ["foo", "bar", "fnord", "blubb"])
+    res.length.should == 6
+    res.should include("bar:foo")
+    res.should include("fnord:foo")
+    res.should include("bar:fnord")
+    res.should include("blubb:foo")
+    res.should include("blubb:fnord")
+    res.should include("bar:blubb")
+  end
+
+  it "should return all_items" do
+    @matrix.add_set("user42", ["fnord", "blubb"])
+    @matrix.add_set("user23", ["hans", "wurst"])
+    @matrix.all_items.length.should == 4
+    @matrix.all_items.should include("wurst")
+    @matrix.all_items.should include("fnord")
+    @matrix.all_items.should include("hans")
+    @matrix.all_items.should include("wurst")
+  end
+
+  it "should delete all item<->item pairs on item deletion" do
+    @matrix.ccmatrix["foo", "fnord"] = 2
+    @matrix.add_set("user123", ["foo", "bar", "fnord"])
+    @matrix.add_set("user456", ["fnord", "blubb"])
+    @matrix.ccmatrix["bar", "foo"].should == 1
+    @matrix.ccmatrix["foo", "fnord"].should == 3
+    @matrix.ccmatrix["blubb", "fnord"].should == 1
+    @matrix.delete_item("fnord")
+    @matrix.ccmatrix["bar", "foo"].should == 1
+    @matrix.ccmatrix["foo", "fnord"].should == 0
+    @matrix.ccmatrix["blubb", "fnord"].should == 0  
+  end
+
+  it "should delete the item count on deletion" do    
+    @matrix.add_set("user123", ["foo", "bar", "fnord"])
+    @matrix.add_set("user456", ["fnord", "blubb"])
+    @matrix.send(:item_count, "fnord").should == 2
+    @matrix.delete_item("fnord")
+    @matrix.send(:item_count, "fnord").should == 0
+  end
+
+end

data/spec/cosine_input_matrix_spec.rb

@@ -0,0 +1,18 @@
+require ::File.expand_path('../spec_helper', __FILE__)
+
+describe Recommendify::CosineInputMatrix do
+
+  before(:all) do
+    @matrix = Recommendify::CosineInputMatrix.new(:redis_prefix => "recommendify-test", :key => "mymatrix")
+  end
+
+  before(:each) do
+    flush_redis!
+  end
+
+  it_should_behave_like Recommendify::InputMatrix
+  it_should_behave_like Recommendify::CCMatrix
+
+  it "should calculate the correct cosine similarity (here be dragons)"
+
+end

data/spec/input_matrix_shared.rb

@@ -0,0 +1,27 @@
+share_examples_for Recommendify::InputMatrix do
+  
+  it "should build the correct keys" do
+    @matrix.redis_key.should == "recommendify-test:mymatrix"
+  end
+
+  it "should respond to add_set" do
+    @matrix.respond_to?(:add_set).should == true
+  end
+
+  it "should respond to add_single" do
+    @matrix.respond_to?(:add_single).should == true
+  end
+
+  it "should respond to similarity" do
+    @matrix.respond_to?(:similarity).should == true
+  end
+
+  it "should respond to similarities_for" do
+    @matrix.respond_to?(:similarities_for).should == true
+  end
+
+  it "should respond to all_items" do
+    @matrix.respond_to?(:all_items).should == true
+  end
+
+end

data/spec/input_matrix_spec.rb

@@ -0,0 +1,29 @@
+require ::File.expand_path('../spec_helper', __FILE__)
+
+describe Recommendify::InputMatrix do
+
+  before(:all) do
+    @matrix = Recommendify::InputMatrix.new(:redis_prefix => "recommendify-test", :key => "mymatrix")
+  end
+
+  before(:each) do
+    flush_redis!
+  end
+
+  it_should_behave_like Recommendify::InputMatrix
+
+  describe "object creation" do
+
+     it "should create an object with the correct class" do
+       obj = Recommendify::InputMatrix.create(:key => "fubar", :similarity_func => :jaccard)
+       obj.should be_a(Recommendify::JaccardInputMatrix)
+     end
+
+     it "should create an object with the correct class and pass opts" do
+       obj = Recommendify::InputMatrix.create(:key => "fubar", :similarity_func => :jaccard)
+       obj.instance_variable_get(:@opts)[:key].should == "fubar"
+     end
+
+  end
+
+end

data/spec/jaccard_input_matrix_spec.rb

@@ -0,0 +1,95 @@
+require ::File.expand_path('../spec_helper', __FILE__)
+
+describe Recommendify::JaccardInputMatrix do
+
+  before(:all) do
+    @matrix = Recommendify::JaccardInputMatrix.new(:redis_prefix => "recommendify-test", :key => "mymatrix")
+  end
+
+  before(:each) do
+    flush_redis!
+  end
+
+  it_should_behave_like Recommendify::InputMatrix
+  it_should_behave_like Recommendify::CCMatrix
+
+  it "should calculate the correct jaccard index" do
+    @matrix.send(:calculate_jaccard, 
+      ["foo", "bar", "fnord", "blubb"],
+      ["bar", "fnord", "shmoo", "snafu"]
+    ).should == 2.0/6.0
+  end
+
+  it "should calculate the correct similarity between to items" do
+    add_two_item_test_data!(@matrix)
+    # sim(fnord,blubb) = (users(fnord) & users(blub)) / (users(fnord) + users(blubb))
+    # => {user42 user48} / {user42 user46 user48 user50} + {user42 user44 user48}
+    # => {user42 user48} / {user42 user44 user46 user48 user50}
+    # => 2 / 5 => 0.4
+    @matrix.similarity("fnord", "blubb").should == 0.4
+    @matrix.similarity("blubb", "fnord").should == 0.4
+  end
+
+  it "should calculate all similarities for an item (1/3)" do
+    add_three_item_test_data!(@matrix)
+    res = @matrix.similarities_for("fnord")
+    res.length.should == 2
+    res.should include ["shmoo", 0.75]
+    res.should include ["blubb", 0.4]
+  end
+
+  it "should calculate all similarities for an item (2/3)" do
+    add_three_item_test_data!(@matrix)
+    res = @matrix.similarities_for("shmoo")
+    res.length.should == 2
+    res.should include ["blubb", 0.2]
+    res.should include ["fnord", 0.75]
+  end
+
+
+  it "should calculate all similarities for an item (3/3)" do
+    add_three_item_test_data!(@matrix)
+    res = @matrix.similarities_for("blubb")
+    res.length.should == 2
+    res.should include ["shmoo", 0.2]
+    res.should include ["fnord", 0.4]
+  end
+
+  it "should call run_native when the native option was passed" do
+    Recommendify::JaccardInputMatrix.class_eval do
+      def check_native; true; end
+    end
+    matrix = Recommendify::JaccardInputMatrix.new(
+      :redis_prefix => "recommendify-test", 
+      :native => true,
+      :key => "mymatrix"
+    )
+    matrix.should_receive(:run_native).with("fnord").and_return(true)
+    matrix.similarities_for("fnord")
+  end
+
+  it "should return the correct redis url" do
+    @matrix.send(:redis_url).should == "127.0.0.1:6379"
+  end
+
+private
+
+  def add_two_item_test_data!(matrix)
+    matrix.add_set("user42", ["fnord", "blubb"])
+    matrix.add_set("user44", ["blubb"])
+    matrix.add_set("user46", ["fnord"])
+    matrix.add_set("user48", ["fnord", "blubb"])
+    matrix.add_set("user50", ["fnord"])
+  end
+
+  def add_three_item_test_data!(matrix)
+    matrix.add_set("user42", ["fnord", "blubb", "shmoo"])
+    matrix.add_set("user44", ["blubb"])
+    matrix.add_set("user46", ["fnord", "shmoo"])
+    matrix.add_set("user48", ["fnord", "blubb"])
+    matrix.add_set("user50", ["fnord", "shmoo"])
+  end
+
+end
+
+

data/spec/recommendify_spec.rb

@@ -0,0 +1,28 @@
+require ::File.expand_path('../spec_helper', __FILE__)
+
+describe Recommendify do
+
+  it "should store a redis connection" do
+    Recommendify.redis = "asd"
+    Recommendify.redis.should == "asd"
+  end
+
+  it "should raise an exception if unconfigured redis connection is accessed" do
+    Recommendify.redis = nil
+    lambda{ ecommendify.redis }.should raise_error
+  end
+
+  it "should capitalize a string" do
+    Recommendify.capitalize("fuubar").should == "Fuubar"
+    Recommendify.capitalize("fuUBar").should == "Fuubar"
+    Recommendify.capitalize("FUUBAR").should == "Fuubar"
+    Recommendify.capitalize("Fuubar").should == "Fuubar"
+  end
+
+  it "should constantize a string" do
+    obj = Recommendify.constantize("JaccardInputMatrix")
+    # should_be doesn't work here...
+    obj.inspect.should == "Recommendify::JaccardInputMatrix"
+  end
+
+end