inferx 0.2.1 → 0.2.2

data/lib/inferx.rb

@@ -2,16 +2,20 @@ require 'redis'
 
 require 'inferx/version'
 require 'inferx/categories'
+require 'inferx/complementary/categories'
 
 class Inferx
 
   # @param [Hash] options other options are passed to Redis#initialize in
   #   {https://github.com/redis/redis-rb redis}
   #
+  # @option options [Boolean] :complementary
   # @option options [String] :namespace namespace of keys to be used to Redis
   # @option options [Boolean] :manual whether manual save, defaults to false
   def initialize(options = {})
-    @categories = Categories.new(Redis.new(options), options)
+    @complementary = !!options[:complementary]
+    categories_class = @complementary ? Complementary::Categories : Categories
+    @categories = categories_class.new(Redis.new(options), options)
   end
 
   attr_reader :categories
@@ -31,7 +35,7 @@ class Inferx
   # Get a score for each category according to a set of words.
   #
   # @param [Array<String>] words a set of words
-  # @return [Hash<Symbol, Float>] scores to key a category
+  # @return [Hash<String, Float>] scores to key a category
   #
   # @see #score
   def classifications(words)
@@ -42,12 +46,13 @@ class Inferx
   # Classify words to any one category.
   #
   # @param [Array<String>] words a set of words
-  # @return [Symbol] most high-scoring category name
+  # @return [String] most high-scoring category name
   #
   # @see #score
   # @see #classifications
   def classify(words)
-    category = classifications(words).max_by { |score| score[1] }
+    method_name = @complementary ? :min_by : :max_by
+    category = classifications(words).__send__(method_name) { |score| score[1] }
     category ? category[0] : nil
   end
 end

data/lib/inferx/adapter.rb

@@ -37,7 +37,7 @@ class Inferx
 
     # Make the key for access to scores stored each by word.
     #
-    # @param [Symbol] category_name a category name
+    # @param [String] category_name a category name
     # @return [String] the key
     def make_category_key(category_name)
       "#{categories_key}:#{category_name}"

data/lib/inferx/categories.rb

@@ -7,25 +7,25 @@ class Inferx
 
     # Get all category names.
     #
-    # @return [Array<Symbol>] category names
+    # @return [Array<String>] category names
     def all
-      (hkeys || []).map(&:to_sym)
+      hkeys || []
     end
 
     # Get a category according the name.
     #
-    # @param [Symbol] category_name a category name
+    # @param [String] category_name a category name
     # @return [Inferx::Category] a category
     def get(category_name)
       size = hget(category_name)
-      raise ArgumentError, "'#{category_name}' is missing" unless size
-      spawn(Category, category_name, size.to_i)
+      raise ArgumentError, "#{category_name.inspect} is missing" unless size
+      spawn_category(category_name, size.to_i)
     end
     alias [] get
 
     # Add categories.
     #
-    # @param [Array<Symbol>] category_names category names
+    # @param [Array<String>] category_names category names
     def add(*category_names)
       @redis.pipelined do
         category_names.each { |category_name| hsetnx(category_name, 0) }
@@ -35,7 +35,7 @@ class Inferx
 
     # Remove categories.
     #
-    # @param [Array<Symbol>] category_names category names
+    # @param [Array<String>] category_names category names
     def remove(*category_names)
       @redis.pipelined do
         category_names.each { |category_name| hdel(category_name) }
@@ -50,8 +50,14 @@ class Inferx
     # @yieldparam [Inferx::Category] category a category
     def each
       hgetall.each do |category_name, size|
-        yield spawn(Category, category_name, size.to_i)
+        yield spawn_category(category_name, size.to_i)
       end
     end
+
+    protected
+
+    def spawn_category(*args)
+      spawn(Category, *args)
+    end
   end
 end

data/lib/inferx/category.rb

@@ -4,21 +4,21 @@ class Inferx
   class Category < Adapter
 
     # @param [Redis] redis an instance of Redis
-    # @param [Symbol] name a category name
+    # @param [String] name a category name
     # @param [Integer] size total of scores
     # @param [Hash] options
     # @option options [String] :namespace namespace of keys to be used to Redis
     # @option options [Boolean] :manual whether manual save, defaults to false
     def initialize(redis, name, size, options = {})
       super(redis, options)
-      @name = name
+      @name = name.to_s
       @size = size
     end
 
     # Get a category name.
     #
     # @attribute [r] name
-    # @return [Symbol] a category name
+    # @return [String] a category name
 
     # Get total of scores.
     #
@@ -57,18 +57,18 @@ class Inferx
     #
     # @param [Array<String>] words an array of words
     def train(words)
+      return if words.empty?
+
+      increase = words.size
+      words = collect(words)
+
       @redis.pipelined do
-        increase = collect(words).inject(0) do |count, pair|
-          zincrby(pair[1], pair[0])
-          count + pair[1]
-        end
-
-        if increase > 0
-          hincrby(name, increase)
-          @redis.save unless manual?
-          @size += increase
-        end
+        words.each { |word, count| zincrby(count, word) }
+        hincrby(name, increase)
+        @redis.save unless manual?
       end
+
+      @size += increase
     end
 
     # Prepare to enhance the training data. Use for high performance.
@@ -83,27 +83,31 @@ class Inferx
     #
     # @param [Array<String>] words an array of words
     def untrain(words)
-      decrease = 0
+      return if words.empty?
 
-      values = @redis.pipelined do
-        decrease = collect(words).inject(0) do |count, pair|
-          zincrby(-pair[1], pair[0])
-          count + pair[1]
-        end
+      decrease = words.size
+      words = collect(words)
 
+      scores = @redis.pipelined do
+        words.each { |word, count| zincrby(-count, word) }
         zremrangebyscore('-inf', 0)
       end
 
-      values[0..-2].each do |score|
+      length = words.size
+
+      scores[0, length].each do |score|
         score = score.to_i
         decrease += score if score < 0
       end
 
-      if decrease > 0
+      return unless decrease > 0
+
+      @redis.pipelined do
         hincrby(name, -decrease)
         @redis.save unless manual?
-        @size -= decrease
       end
+
+      @size -= decrease
     end
 
     # Prepare to attenuate the training data giving words.
@@ -123,7 +127,7 @@ class Inferx
       scores.map { |score| score ? score.to_i : nil }
     end
 
-    private
+    protected
 
     %w(zrevrange zscore zincrby zremrangebyscore).each do |command|
       define_method(command) do |*args|

data/lib/inferx/complementary/categories.rb

@@ -0,0 +1,14 @@
+require 'inferx/categories'
+require 'inferx/complementary/category'
+
+class Inferx
+  module Complementary
+    class Categories < Inferx::Categories
+      protected
+
+      def spawn_category(*args)
+        spawn(Category, *args)
+      end
+    end
+  end
+end

data/lib/inferx/complementary/category.rb

@@ -0,0 +1,82 @@
+require 'inferx/category'
+
+class Inferx
+  module Complementary
+    class Category < Inferx::Category
+
+      # Enhance the training data of other categories giving words.
+      #
+      # @param [Array<String>] words an array of words
+      def train(words)
+        return if words.empty?
+
+        increase = words.size
+        words = collect(words)
+
+        category_names = get_other_category_names
+        return if category_names.empty?
+
+        @redis.pipelined do
+          category_names.each do |category_name|
+            category_key = make_category_key(category_name)
+            words.each { |word, count| @redis.zincrby(category_key, count, word) }
+            hincrby(category_name, increase)
+          end
+
+          @redis.save unless manual?
+        end
+      end
+
+      # Attenuate the training data of other categories giving words.
+      #
+      # @param [Array<String>] words an array of words
+      def untrain(words)
+        return if words.empty?
+
+        decrease = words.size
+        words = collect(words)
+
+        category_names = get_other_category_names
+        return if category_names.empty?
+
+        scores = @redis.pipelined do
+          category_names.each do |category_name|
+            category_key = make_category_key(category_name)
+            words.each { |word, count| @redis.zincrby(category_key, -count, word) }
+            @redis.zremrangebyscore(category_key, '-inf', 0)
+          end
+        end
+
+        length = words.size
+        decreases_by_category = {}
+
+        category_names.each_with_index do |category_name, index|
+          decrease_by_category = decrease
+
+          scores[index * (length + 1), length].each do |score|
+            score = score.to_i
+            decrease_by_category += score if score < 0
+          end
+
+          decreases_by_category[category_name] = decrease_by_category if decrease_by_category > 0
+        end
+
+        return if decreases_by_category.empty?
+
+        @redis.pipelined do
+          decreases_by_category.each do |category_name, decrease|
+            hincrby(category_name, -decrease)
+          end
+
+          @redis.save unless manual?
+        end
+      end
+
+      private
+
+      def get_other_category_names
+        hkeys.reject { |category_name| category_name == name }
+      end
+    end
+  end
+end

data/lib/inferx/version.rb

@@ -1,3 +1,3 @@
 class Inferx
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/spec/inferx/adapter_spec.rb

@@ -65,13 +65,13 @@ end
 describe Inferx::Adapter, '#make_category_key' do
   it 'returns the key for access to scores stored each by word' do
     adapter = described_class.new(redis_stub)
-    adapter.make_category_key(:red).should == 'inferx:categories:red'
+    adapter.make_category_key('red').should == 'inferx:categories:red'
   end
 
   context 'with namespace' do
     it 'returns the key included the namespace' do
       adapter = described_class.new(redis_stub, :namespace => 'example')
-      adapter.make_category_key(:red).should == 'inferx:example:categories:red'
+      adapter.make_category_key('red').should == 'inferx:example:categories:red'
     end
   end
 end
@@ -86,7 +86,7 @@ describe Inferx::Adapter, '#spawn' do
 
   it 'returns an instance of the class' do
     adapter = described_class.new(redis_stub)
-    klass = stub.tap { |s| s.stub!(:new).and_return('klass') }
+    klass = stub.tap { |s| s.stub!(:new => 'klass') }
     adapter.spawn(klass).should == 'klass'
   end
 end

data/spec/inferx/categories_spec.rb

@@ -27,18 +27,9 @@ describe Inferx::Categories, '#all' do
     categories.all
   end
 
-  it 'returns the all categories as Symbol' do
-    redis = redis_stub do |s|
-      s.stub!(:hkeys).and_return(%w(red green blue))
-    end
-
-    categories = described_class.new(redis)
-    categories.all.should == [:red, :green, :blue]
-  end
-
   it 'returns an empty array if the key is missing' do
     redis = redis_stub do |s|
-      s.stub!(:hkeys).and_return([])
+      s.stub!(:hkeys => [])
     end
 
     categories = described_class.new(redis)
@@ -49,40 +40,40 @@ end
 describe Inferx::Categories, '#get' do
   it 'calls Redis#hget' do
     redis = redis_stub do |s|
-      s.should_receive(:hget).with('inferx:categories', :red).and_return('2')
+      s.should_receive(:hget).with('inferx:categories', 'red').and_return('2')
     end
 
     categories = described_class.new(redis)
-    categories.get(:red)
+    categories.get('red')
   end
 
   it 'calles Inferx::Category.new with the instance of Redis, the category name and the options' do
     redis = redis_stub do |s|
-      s.stub!(:hget).and_return('2')
+      s.stub!(:hget => '2')
     end
 
-    Inferx::Category.should_receive(:new).with(redis, :red, 2, :namespace => 'example', :manual => true)
+    Inferx::Category.should_receive(:new).with(redis, 'red', 2, :namespace => 'example', :manual => true)
     categories = described_class.new(redis, :namespace => 'example', :manual => true)
-    categories.get(:red)
+    categories.get('red')
   end
 
   it 'returns an instance of Inferx::Category' do
     redis = redis_stub do |s|
-      s.stub!(:hget).and_return('2')
+      s.stub!(:hget => '2')
     end
 
     categories = described_class.new(redis)
-    categories.get(:red).should be_an(Inferx::Category)
+    categories.get('red').should be_an(Inferx::Category)
   end
 
   context 'with a missing category' do
     it 'raises ArgumentError' do
       redis = redis_stub do |s|
-        s.stub!(:hget).and_return(nil)
+        s.stub!(:hget => nil)
       end
 
       categories = described_class.new(redis)
-      lambda { categories.get(:red) }.should raise_error(ArgumentError, /'red' is missing/)
+      lambda { categories.get('red') }.should raise_error(ArgumentError, /"red" is missing/)
     end
   end
 end
@@ -90,23 +81,23 @@ end
 describe Inferx::Categories, '#add' do
   it 'calls Redis#hsetnx' do
     redis = redis_stub do |s|
-      s.should_receive(:hsetnx).with('inferx:categories', :red, 0)
+      s.should_receive(:hsetnx).with('inferx:categories', 'red', 0)
       s.should_receive(:save)
     end
 
     categories = described_class.new(redis)
-    categories.add(:red)
+    categories.add('red')
   end
 
   it 'calls Redis#hsetnx according to the number of the categories' do
     redis = redis_stub do |s|
-      s.should_receive(:hsetnx).with('inferx:categories', :red, 0)
-      s.should_receive(:hsetnx).with('inferx:categories', :green, 0)
+      s.should_receive(:hsetnx).with('inferx:categories', 'red', 0)
+      s.should_receive(:hsetnx).with('inferx:categories', 'green', 0)
       s.should_receive(:save)
     end
 
     categories = described_class.new(redis)
-    categories.add(:red, :green)
+    categories.add('red', 'green')
   end
 
   context 'with manual save' do
@@ -117,7 +108,7 @@ describe Inferx::Categories, '#add' do
       end
 
       categories = described_class.new(redis, :manual => true)
-      categories.add(:red)
+      categories.add('red')
     end
   end
 end
@@ -125,25 +116,25 @@ end
 describe Inferx::Categories, '#remove' do
   it 'calls Redis#hdel and Redis#del' do
     redis = redis_stub do |s|
-      s.should_receive(:hdel).with('inferx:categories', :red)
+      s.should_receive(:hdel).with('inferx:categories', 'red')
       s.should_receive(:del).with('inferx:categories:red')
       s.should_receive(:save)
     end
 
     categories = described_class.new(redis)
-    categories.remove(:red)
+    categories.remove('red')
   end
 
   it 'calls Redis#hdel according to the number of the categories' do
     redis = redis_stub do |s|
-      s.should_receive(:hdel).with('inferx:categories', :red)
-      s.should_receive(:hdel).with('inferx:categories', :green)
+      s.should_receive(:hdel).with('inferx:categories', 'red')
+      s.should_receive(:hdel).with('inferx:categories', 'green')
       s.should_receive(:del).with('inferx:categories:red', 'inferx:categories:green')
       s.should_receive(:save)
     end
 
     categories = described_class.new(redis)
-    categories.remove(:red, :green)
+    categories.remove('red', 'green')
   end
 
   context 'with manual save' do
@@ -155,7 +146,7 @@ describe Inferx::Categories, '#remove' do
       end
 
       categories = described_class.new(redis, :manual => true)
-      categories.remove(:red)
+      categories.remove('red')
     end
   end
 end
@@ -163,7 +154,11 @@ end
 describe Inferx::Categories, '#each' do
   before do
     @redis = redis_stub do |s|
-      s.stub!(:hgetall).and_return(%w(red green blue))
+      s.stub!(:hgetall => {
+        'red'   => 2,
+        'green' => 3,
+        'blue'  => 1
+      })
     end
   end
 
@@ -179,3 +174,20 @@ describe Inferx::Categories, '#each' do
     n.should == 3
   end
 end
+
+describe Inferx::Categories, '#spawn_category' do
+  before do
+    @categories = described_class.new(redis_stub).tap do |s|
+      s.stub!(:spawn => 'category')
+    end
+  end
+
+  it 'calls #spawn with Inferx::Category and the arguments' do
+    @categories.should_receive(:spawn).with(Inferx::Category, 'arg1', 'arg2')
+    @categories.__send__(:spawn_category, 'arg1', 'arg2')
+  end
+
+  it 'returns the return value from #spawn' do
+    @categories.__send__(:spawn_category, 'arg1', 'arg2').should == 'category'
+  end
+end

data/spec/inferx/category_spec.rb

@@ -4,19 +4,19 @@ require 'inferx/category'
 describe Inferx::Category, '#initialize' do
   it 'calls Inferx::Adapter#initialize' do
     redis = redis_stub
-    category = described_class.new(redis, :red, 2, :namespace => 'example', :manual => true)
+    category = described_class.new(redis, 'red', 2, :namespace => 'example', :manual => true)
     category.instance_eval { @redis }.should == redis
     category.instance_eval { @namespace }.should == 'example'
     category.should be_manual
   end
 
   it 'sets the category name to the name attribute' do
-    category = described_class.new(redis_stub, :red, 2)
-    category.name.should == :red
+    category = described_class.new(redis_stub, 'red', 2)
+    category.name.should == 'red'
   end
 
   it 'sets the size to the size attribute' do
-    category = described_class.new(redis_stub, :red, 2)
+    category = described_class.new(redis_stub, 'red', 2)
     category.size.should == 2
   end
 end
@@ -27,7 +27,7 @@ describe Inferx::Category, '#all' do
       s.should_receive(:zrevrange).with('inferx:categories:red', 0, -1, :withscores => true).and_return([])
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     category.all
   end
 
@@ -36,7 +36,7 @@ describe Inferx::Category, '#all' do
       s.stub!(:zrevrange).with('inferx:categories:red', 0, -1, :withscores => true).and_return(%w(apple 2 strawberry 3))
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     category.all.should == {'apple' => 2, 'strawberry' => 3}
   end
 end
@@ -47,7 +47,7 @@ describe Inferx::Category, '#get' do
       s.should_receive(:zscore).with('inferx:categories:red', 'apple')
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     category.get('apple')
   end
 
@@ -56,7 +56,7 @@ describe Inferx::Category, '#get' do
       s.stub!(:zscore).with('inferx:categories:red', 'apple').and_return('1')
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     category.get('apple').should == 1
   end
 
@@ -66,7 +66,7 @@ describe Inferx::Category, '#get' do
         s.stub!(:zscore).with('inferx:categories:red', 'strawberry').and_return(nil)
       end
 
-      category = described_class.new(redis, :red, 2)
+      category = described_class.new(redis, 'red', 2)
       category.get('strawberry').should be_nil
     end
   end
@@ -77,11 +77,11 @@ describe Inferx::Category, '#train' do
     redis = redis_stub do |s|
       s.should_receive(:zincrby).with('inferx:categories:red', 2, 'apple')
       s.should_receive(:zincrby).with('inferx:categories:red', 3, 'strawberry')
-      s.should_receive(:hincrby).with('inferx:categories', :red, 5)
+      s.should_receive(:hincrby).with('inferx:categories', 'red', 5)
       s.should_receive(:save)
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     category.train(%w(apple strawberry apple strawberry strawberry))
   end
 
@@ -91,7 +91,7 @@ describe Inferx::Category, '#train' do
       s.stub!(:hincrby)
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     category.train(%w(apple strawberry apple strawberry strawberry))
     category.size.should == 7
   end
@@ -103,8 +103,8 @@ describe Inferx::Category, '#train' do
         s.should_not_receive(:save)
       end
 
-      category = described_class.new(redis, :red, 2)
-      category.train(%w())
+      category = described_class.new(redis, 'red', 2)
+      category.train([])
     end
   end
 
@@ -116,7 +116,7 @@ describe Inferx::Category, '#train' do
         s.should_not_receive(:save)
       end
 
-      category = described_class.new(redis, :red, 2, :manual => true)
+      category = described_class.new(redis, 'red', 2, :manual => true)
       category.train(%w(apple strawberry apple strawberry strawberry))
     end
   end
@@ -124,7 +124,7 @@ end
 
 describe Inferx::Category, '#ready_to_train' do
   it 'calls #train with the words to train block' do
-    category = described_class.new(redis_stub, :red, 2)
+    category = described_class.new(redis_stub, 'red', 2)
     category.should_receive(:train).with(%w(word1 word2 word3))
 
     category.ready_to_train do |train|
@@ -138,39 +138,54 @@ end
 describe Inferx::Category, '#untrain' do
   it 'calls Redis#zincrby, Redis#zremrangebyscore and Redis#hincrby' do
     redis = redis_stub do |s|
+      s.stub!(:pipelined).and_return do |&block|
+        block.call
+        %w(3 -2 1)
+      end
+
       s.should_receive(:zincrby).with('inferx:categories:red', -2, 'apple')
       s.should_receive(:zincrby).with('inferx:categories:red', -3, 'strawberry')
-      s.should_receive(:zremrangebyscore).with('inferx:categories:red', '-inf', 0).and_return(%w(3 -2 1))
-      s.should_receive(:hincrby).with('inferx:categories', :red, -3)
+      s.should_receive(:zremrangebyscore).with('inferx:categories:red', '-inf', 0)
+      s.should_receive(:hincrby).with('inferx:categories', 'red', -3)
       s.should_receive(:save)
     end
 
-    category = described_class.new(redis, :red, 7)
+    category = described_class.new(redis, 'red', 7)
     category.untrain(%w(apple strawberry apple strawberry strawberry))
   end
 
   it 'decreases the size attribute' do
     redis = redis_stub do |s|
+      s.stub!(:pipelined).and_return do |&block|
+        block.call
+        %w(3 -2 1)
+      end
+
       s.stub!(:zincrby)
-      s.stub!(:zremrangebyscore).and_return(%w(3 -2 1))
+      s.stub!(:zremrangebyscore)
       s.stub!(:hincrby)
     end
 
-    category = described_class.new(redis, :red, 7)
+    category = described_class.new(redis, 'red', 7)
     category.untrain(%w(apple strawberry apple strawberry strawberry))
     category.size.should == 4
   end
 
   context 'with no update' do
-    it 'does not call Redis#hincrby' do
+    it 'does not call Redis#zremrangebyscore and Redis#hincrby' do
       redis = redis_stub do |s|
+        s.stub!(:pipelined).and_return do |&block|
+          block.call
+          %w(-2 -3 2)
+        end
+
         s.stub!(:zincrby)
-        s.stub!(:zremrangebyscore).and_return(%w(-2 -3 2))
+        s.stub!(:zremrangebyscore)
         s.should_not_receive(:hincrby)
         s.should_not_receive(:save)
       end
 
-      category = described_class.new(redis, :red, 7)
+      category = described_class.new(redis, 'red', 7)
       category.untrain(%w(apple strawberry apple strawberry strawberry))
     end
   end
@@ -178,13 +193,18 @@ describe Inferx::Category, '#untrain' do
   context 'with manual save' do
     it 'does not call Redis#save' do
       redis = redis_stub do |s|
+        s.stub!(:pipelined).and_return do |&block|
+          block.call
+          %w(3 -2 1)
+        end
+
         s.stub!(:zincrby)
-        s.stub!(:zremrangebyscore).and_return(%w(3 -2 1))
+        s.stub!(:zremrangebyscore)
         s.stub!(:hincrby)
         s.should_not_receive(:save)
       end
 
-      category = described_class.new(redis, :red, 7, :manual => true)
+      category = described_class.new(redis, 'red', 7, :manual => true)
       category.untrain(%w(apple strawberry apple strawberry strawberry))
     end
   end
@@ -192,7 +212,7 @@ end
 
 describe Inferx::Category, '#ready_to_untrain' do
   it 'calls #untrain with the words to untrain block' do
-    category = described_class.new(redis_stub, :red, 2)
+    category = described_class.new(redis_stub, 'red', 2)
     category.should_receive(:untrain).with(%w(word1 word2 word3))
 
     category.ready_to_untrain do |untrain|
@@ -210,16 +230,16 @@ describe Inferx::Category, '#scores' do
       s.should_receive(:zscore).with('inferx:categories:red', 'strawberry')
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     category.scores(%w(apple strawberry))
   end
 
   it 'returns the scores' do
     redis = redis_stub do |s|
-      s.stub!(:pipelined).and_return(%w(2 3))
+      s.stub!(:pipelined => %w(2 3))
     end
 
-    category = described_class.new(redis, :red, 2)
+    category = described_class.new(redis, 'red', 2)
     scores = category.scores(%w(apple strawberry))
     scores.should == [2, 3]
   end

data/spec/inferx/complementary/categories_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'inferx/complementary/categories'
+
+describe Inferx::Complementary::Categories do
+  it 'inherits Inferx::Categories' do
+    described_class.superclass.should == Inferx::Categories
+  end
+end
+
+describe Inferx::Complementary::Categories, '#spawn_category' do
+  before do
+    @categories = described_class.new(redis_stub).tap do |s|
+      s.stub!(:spawn => 'category')
+    end
+  end
+
+  it 'calls #spawn with Inferx::Complementary::Category, the categories and the arguments' do
+    @categories.should_receive(:spawn).with(Inferx::Complementary::Category, 'arg1', 'arg2')
+    @categories.__send__(:spawn_category, 'arg1', 'arg2')
+  end
+
+  it 'returns the return value from #spawn' do
+    @categories.__send__(:spawn_category, 'arg1', 'arg2').should == 'category'
+  end
+end

data/spec/inferx/complementary/category_spec.rb

@@ -0,0 +1,113 @@
+require 'inferx/complementary/category'
+
+describe Inferx::Complementary::Category, '#train' do
+  it 'calls Redis#zincrby and Redis#hincrby for other categories' do
+    redis = redis_stub do |s|
+      s.stub!(:hkeys => %w(red green blue))
+      s.should_receive(:zincrby).with('inferx:categories:green', 2, 'apple')
+      s.should_receive(:zincrby).with('inferx:categories:green', 3, 'strawberry')
+      s.should_receive(:hincrby).with('inferx:categories', 'green', 5)
+      s.should_receive(:zincrby).with('inferx:categories:blue', 2, 'apple')
+      s.should_receive(:zincrby).with('inferx:categories:blue', 3, 'strawberry')
+      s.should_receive(:hincrby).with('inferx:categories', 'blue', 5)
+      s.should_receive(:save)
+    end
+
+    category = described_class.new(redis, 'red', 2)
+    category.train(%w(apple strawberry apple strawberry strawberry))
+  end
+
+  context 'with no update' do
+    it 'does not call Redis#hincrby' do
+      redis = redis_stub do |s|
+        s.should_not_receive(:hincrby)
+        s.should_not_receive(:save)
+      end
+
+      category = described_class.new(redis, 'red', 2)
+      category.train([])
+    end
+  end
+
+  context 'with manual save' do
+    it 'does not call Redis#save' do
+      redis = redis_stub do |s|
+        s.stub!(:hkeys => %w(red green blue))
+        s.stub!(:zincrby)
+        s.stub!(:hincrby)
+        s.should_not_receive(:save)
+      end
+
+      category = described_class.new(redis, 'red', 2, :manual => true)
+      category.train(%w(apple strawberry apple strawberry strawberry))
+    end
+  end
+end
+
+describe Inferx::Complementary::Category, '#untrain' do
+  it 'calls Redis#zincrby, Redis#zremrangebyscore and Redis#hincrby for other categories' do
+    redis = redis_stub do |s|
+      s.stub!(:hkeys => %w(red green blue))
+
+      s.stub!(:pipelined).and_return do |&block|
+        block.call
+        %w(1 1 0 2 -1 1)
+      end
+
+      s.should_receive(:zincrby).with('inferx:categories:green', -2, 'apple')
+      s.should_receive(:zincrby).with('inferx:categories:green', -3, 'strawberry')
+      s.should_receive(:zremrangebyscore).with('inferx:categories:green', '-inf', 0)
+      s.should_receive(:zincrby).with('inferx:categories:blue', -2, 'apple')
+      s.should_receive(:zincrby).with('inferx:categories:blue', -3, 'strawberry')
+      s.should_receive(:zremrangebyscore).with('inferx:categories:blue', '-inf', 0)
+      s.should_receive(:hincrby).with('inferx:categories', 'green', -5)
+      s.should_receive(:hincrby).with('inferx:categories', 'blue', -4)
+      s.should_receive(:save)
+    end
+
+    category = described_class.new(redis, 'red', 2)
+    category.untrain(%w(apple strawberry apple strawberry strawberry))
+  end
+
+  context 'with no update' do
+    it 'does not call Redis#zremrangebyscore and Redis#hincrby' do
+      redis = redis_stub do |s|
+        s.stub!(:hkeys => %w(red green blue))
+
+        s.stub!(:pipelined).and_return do |&block|
+          block.call
+          %w(-3 -2 2 -3 -2 2)
+        end
+
+        s.stub!(:zincrby)
+        s.stub!(:zremrangebyscore)
+        s.should_not_receive(:hincrby)
+        s.should_not_receive(:save)
+      end
+
+      category = described_class.new(redis, 'red', 2)
+      category.untrain([])
+    end
+  end
+
+  context 'with manual save' do
+    it 'does not call Redis#save' do
+      redis = redis_stub do |s|
+        s.stub!(:hkeys => %w(red green blue))
+
+        s.stub!(:pipelined).and_return do |&block|
+          block.call
+          %w(1 1 0 2 -1 1)
+        end
+
+        s.stub!(:zincrby)
+        s.stub!(:zremrangebyscore)
+        s.stub!(:hincrby)
+        s.should_not_receive(:save)
+      end
+
+      category = described_class.new(redis, 'red', 2, :manual => true)
+      category.untrain(%w(apple strawberry apple strawberry strawberry))
+    end
+  end
+end

data/spec/inferx_spec.rb

@@ -23,6 +23,14 @@ describe Inferx, '#initialize' do
     inferx = described_class.new
     inferx.categories.should be_an(Inferx::Categories)
   end
+
+  context 'with :complementary option' do
+    it "sets an instance of #{described_class}::Complementary::Categories to the categories attribute" do
+      redis_stub
+      inferx = described_class.new(:complementary => true)
+      inferx.categories.should be_an(Inferx::Complementary::Categories)
+    end
+  end
 end
 
 describe Inferx, '#score' do
@@ -48,8 +56,7 @@ describe Inferx, '#score' do
       words, size, scores = args
 
       category = stub.tap do |s|
-        s.stub!(:size).and_return(size)
-        s.stub!(:scores).and_return(scores)
+        s.stub!(:size => size, :scores => scores)
       end
 
       @inferx.score(category, words).should == expected
@@ -58,7 +65,7 @@ describe Inferx, '#score' do
 
   it 'returns a negative infinity number if the category does not have words' do
     category = stub.tap do |s|
-      s.stub!(:size).and_return(0)
+      s.stub!(:size => 0)
     end
 
     score = @inferx.score(category, %w(apple))
@@ -68,8 +75,7 @@ describe Inferx, '#score' do
 
   it 'returns 0.0 if the words are empty' do
     category = stub.tap do |s|
-      s.stub!(:size).and_return(2)
-      s.stub!(:scores).and_return([])
+      s.stub!(:size => 2, :scores => [])
     end
 
     score = @inferx.score(category, [])
@@ -80,8 +86,8 @@ end
 
 describe Inferx, '#classifications' do
   before do
-    categories = [:red, :green, :blue].map do |category_name|
-      stub.tap { |s| s.stub!(:name).and_return(category_name) }
+    categories = %w(red green blue).map do |category_name|
+      stub.tap { |s| s.stub!(:name => category_name) }
     end
 
     @inferx = described_class.new.tap do |s|
@@ -110,9 +116,9 @@ describe Inferx, '#classifications' do
 
   it 'returns the scores to key the category name' do
     @inferx.classifications(%w(apple)).should == {
-      :red   => 'score of red',
-      :green => 'score of green',
-      :blue  => 'score of blue'
+      'red'   => 'score of red',
+      'green' => 'score of green',
+      'blue'  => 'score of blue'
     }
   end
 end
@@ -120,27 +126,39 @@ end
 describe Inferx, '#classify' do
   before do
     @inferx = described_class.new.tap do |s|
-      s.stub!(:classifications).and_return(:red => -2, :green => -1, :blue => -3)
+      s.stub!(:classifications => {'red' => -2, 'green' => -1, 'blue' => -3})
     end
   end
 
   it "calls #{described_class}#classifications" do
     @inferx.tap do |m|
-      m.should_receive(:classifications).with(%w(apple)).and_return(:red => -2)
+      m.should_receive(:classifications).with(%w(apple)).and_return('red' => -2)
     end
 
     @inferx.classify(%w(apple))
   end
 
   it 'returns the most high-scoring category' do
-    @inferx.classify(%w(apple)).should == :green
+    @inferx.classify(%w(apple)).should == 'green'
   end
 
   it 'returns nil if the categories is nothing' do
     @inferx.tap do |s|
-      s.stub!(:classifications).and_return({})
+      s.stub!(:classifications => {})
     end
 
     @inferx.classify(%w(apple)).should be_nil
   end
+
+  context 'when construct with :complementary option' do
+    before do
+      @inferx = described_class.new(:complementary => true).tap do |s|
+        s.stub!(:classifications => {'red' => -2, 'green' => -1, 'blue' => -3})
+      end
+    end
+
+    it 'returns the most lower-scoring category' do
+      @inferx.classify(%w(apple)).should == 'blue'
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -3,6 +3,6 @@ def redis_stub
     s.stub!(:pipelined).and_return { |&block| block.call }
     s.stub!(:save)
     yield s if block_given?
-    Redis.stub!(:new).and_return(s) if defined? Redis
+    Redis.stub!(:new => s) if defined? Redis
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inferx
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-17 00:00:00.000000000 Z
+date: 2012-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -61,10 +61,14 @@ files:
 - lib/inferx/adapter.rb
 - lib/inferx/categories.rb
 - lib/inferx/category.rb
+- lib/inferx/complementary/categories.rb
+- lib/inferx/complementary/category.rb
 - lib/inferx/version.rb
 - spec/inferx/adapter_spec.rb
 - spec/inferx/categories_spec.rb
 - spec/inferx/category_spec.rb
+- spec/inferx/complementary/categories_spec.rb
+- spec/inferx/complementary/category_spec.rb
 - spec/inferx_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -95,6 +99,8 @@ test_files:
 - spec/inferx/adapter_spec.rb
 - spec/inferx/categories_spec.rb
 - spec/inferx/category_spec.rb
+- spec/inferx/complementary/categories_spec.rb
+- spec/inferx/complementary/category_spec.rb
 - spec/inferx_spec.rb
 - spec/spec_helper.rb
 has_rdoc: