inferx 0.2.3 → 0.2.4

data/lib/inferx/complementary/categories.rb

@@ -1,14 +0,0 @@
-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

@@ -1,108 +0,0 @@
-require 'inferx/category'
-
-class Inferx
-  module Complementary
-    class Category < Inferx::Category
-
-      # Inject the words to the training data of the category.
-      #
-      # @param [Array<String>] words an array of words
-      alias inject train
-
-      # Eject the words from the training data of the category.
-      #
-      # @param [Array<String>] words an array of words
-      alias eject untrain
-
-      # Prepare to inject the words to the training data of the category. Use
-      # for high performance.
-      #
-      # @yield [train] process something
-      # @yieldparam [Proc] inject inject the words to the training data of the
-      #   category
-      ready_for :inject
-
-      # Prepare to eject the words from the training data of the category. Use
-      # for high performance.
-      #
-      # @yield [train] process something
-      # @yieldparam [Proc] eject eject the words from the training data of the
-      #   category
-      ready_for :eject
-
-      # 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/spec/inferx/adapter_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require 'inferx/adapter'
-
-describe Inferx::Adapter, '#initialize' do
-  it 'sets the instance of Redis to @redis' do
-    redis = redis_stub
-    adapter = described_class.new(redis)
-    adapter.instance_eval { @redis }.should == redis
-  end
-
-  it 'sets nil to @namespace' do
-    adapter = described_class.new(redis_stub)
-    adapter.instance_eval { @namespace }.should be_nil
-  end
-
-  it 'sets false to @manual' do
-    adapter = described_class.new(redis_stub)
-    adapter.should_not be_manual
-  end
-
-  context 'with namespace option' do
-    it 'sets the value of namespace option to @namespace' do
-      adapter = described_class.new(redis_stub, :namespace => 'example')
-      adapter.instance_eval { @namespace }.should == 'example'
-    end
-  end
-
-  context 'with manual option' do
-    it 'sets the value of manual option to @manual' do
-      adapter = described_class.new(redis_stub, :manual => true)
-      adapter.should be_manual
-    end
-  end
-end
-
-describe Inferx::Adapter, '#categories_key' do
-  it "calls #{described_class}#make_category_key" do
-    adapter = described_class.new(redis_stub)
-    adapter.should_receive(:make_categories_key)
-    adapter.categories_key
-  end
-
-  it "calls #{described_class}#make_category_key once in same instance" do
-    adapter = described_class.new(redis_stub)
-    adapter.should_receive(:make_categories_key).and_return('inferx:categories')
-    adapter.categories_key
-    adapter.categories_key
-  end
-end
-
-describe Inferx::Adapter, '#make_categories_key' do
-  it 'returns the key for access to categories' do
-    adapter = described_class.new(redis_stub)
-    adapter.categories_key.should == 'inferx:categories'
-  end
-
-  context 'with namespace' do
-    it 'returns the key included the namespace' do
-      adapter = described_class.new(redis_stub, :namespace => 'example')
-      adapter.categories_key.should == 'inferx:example:categories'
-    end
-  end
-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'
-  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'
-    end
-  end
-end
-
-describe Inferx::Adapter, '#spawn' do
-  it 'calls constructor of the class with the instance variables and the arguments' do
-    redis = redis_stub
-    adapter = described_class.new(redis, :namespace => 'example')
-    klass = mock.tap { |m| m.should_receive(:new).with(redis, 'arg1', 'arg2', :namespace => 'example') }
-    adapter.spawn(klass, 'arg1', 'arg2')
-  end
-
-  it 'returns an instance of the class' do
-    adapter = described_class.new(redis_stub)
-    klass = stub.tap { |s| s.stub!(:new => 'klass') }
-    adapter.spawn(klass).should == 'klass'
-  end
-end

data/spec/inferx/complementary/categories_spec.rb

@@ -1,25 +0,0 @@
-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

@@ -1,139 +0,0 @@
-require 'inferx/complementary/category'
-
-describe Inferx::Complementary::Category, '#ready_to_inject' do
-  it 'calls #inject with the words to inject block' do
-    category = described_class.new(redis_stub, 'red', 2)
-    category.should_receive(:inject).with(%w(word1 word2 word3))
-
-    category.ready_to_inject do |inject|
-      inject[%w(word1)]
-      inject[%w(word2)]
-      inject[%w(word3)]
-    end
-  end
-end
-
-describe Inferx::Complementary::Category, '#ready_to_eject' do
-  it 'calls #eject with the words to eject block' do
-    category = described_class.new(redis_stub, 'red', 2)
-    category.should_receive(:eject).with(%w(word1 word2 word3))
-
-    category.ready_to_eject do |eject|
-      eject[%w(word1)]
-      eject[%w(word2)]
-      eject[%w(word3)]
-    end
-  end
-end
-
-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