inferx 0.1.5

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in inferx.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Takahiro Kondo
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+What is inferx
+==============
+
+It is Naive Bayes classifier, and the training data is kept always by Redis.
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'inferx'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install inferx
+
+Usage
+-----
+
+    require 'inferx'
+
+    inferx = Inferx.new
+    inferx.categories.add(:red, :green, :blue)
+
+    inferx.categories[:red].train(%w(
+      he
+      buy
+      apple
+      its
+      apple
+      fresh
+    ))
+
+    inferx.categories[:green].train(%w(grasses ...))
+    inferx.categories[:blue].train(%w(sea ...))
+
+    puts inferx.classify(%w(apple ...)) # => red
+
+Contributing
+------------
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/inferx.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/inferx/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Takahiro Kondo"]
+  gem.email         = ["kondo@atedesign.net"]
+  gem.description   = %q{It is Naive Bayes classifier, and the training data is kept always by Redis.}
+  gem.summary       = %q{Naive Bayes classifier, the training data on Redis}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "inferx"
+  gem.require_paths = ["lib"]
+  gem.version       = Inferx::VERSION
+
+  gem.add_runtime_dependency 'redis'
+
+  gem.add_development_dependency 'rspec'
+end

data/lib/inferx/adapter.rb

@@ -0,0 +1,52 @@
+class Inferx
+  class Adapter
+
+    # @param [Redis] an instance of Redis
+    # @param [String] namespace of keys to be used to Redis
+    def initialize(redis, namespace = nil)
+      @redis = redis
+      @namespace = namespace
+    end
+
+    # Get the key for access to categories.
+    #
+    # @return [String] the key
+    def categories_key
+      @categories_key ||= make_categories_key
+    end
+
+    # Make the key for access to categories.
+    #
+    # @return [String] the key
+    def make_categories_key
+      parts = %w(inferx categories)
+      parts.insert(1, @namespace) if @namespace
+      parts.join(':')
+    end
+
+    # Make the key for access to scores stored each by word.
+    #
+    # @param [Symbol] a category name
+    # @return [String] the key
+    def make_category_key(category_name)
+      "#{categories_key}:#{category_name}"
+    end
+
+    # Spawn an instance of any class.
+    #
+    # @param [Class] any class, constructor takes the instance of Redis to
+    #   first argument, and takes the namespace to last argument
+    # @return [Object] a instance of the class
+    def spawn(klass, *args)
+      klass.new(@redis, *args, @namespace)
+    end
+
+    protected
+
+    %w(hdel hexists hget hincrby hkeys hsetnx).each do |command|
+      define_method(command) do |*args|
+        @redis.__send__(command, categories_key, *args)
+      end
+    end
+  end
+end

data/lib/inferx/categories.rb

@@ -0,0 +1,53 @@
+require 'inferx/adapter'
+require 'inferx/category'
+
+class Inferx
+  class Categories < Adapter
+
+    # Get all category names.
+    #
+    # @return [Array<Symbol>] category names
+    def all
+      (hkeys || []).map(&:to_sym)
+    end
+
+    # Get a category according name.
+    #
+    # @param [Symbol] category name
+    # @return [Inferx::Category] category
+    def get(category_name)
+      raise ArgumentError, "'#{category_name}' is missing" unless hexists(category_name)
+      spawn(Category, category_name)
+    end
+    alias [] get
+
+    # Add categories.
+    #
+    # @param [Array<Symbol>] category names
+    def add(*category_names)
+      @redis.pipelined do
+        category_names.each { |category_name| hsetnx(category_name, 0) }
+      end
+    end
+
+    # Remove categories.
+    #
+    # @param [Array<Symbol>] category names
+    def remove(*category_names)
+      @redis.pipelined do
+        category_names.each { |category_name| hdel(category_name) }
+        @redis.del(*category_names.map(&method(:make_category_key)))
+      end
+    end
+
+    include Enumerable
+
+    # Apply process for each category.
+    #
+    # @yield a block to be called for every category
+    # @yieldparam [Inferx::Category] category
+    def each
+      all.each { |category_name| yield spawn(Category, category_name) }
+    end
+  end
+end

data/lib/inferx/category.rb

@@ -0,0 +1,139 @@
+require 'inferx/adapter'
+
+class Inferx
+  class Category < Adapter
+
+    # @param [Redis] an instance of Redis
+    # @param [Symbol] a category name
+    # @param [String] namespace of keys to be used to Redis
+    def initialize(redis, name, namespace = nil)
+      super(redis, namespace)
+      @name = name
+    end
+
+    attr_reader :name
+
+    # Get words with scores in the category.
+    #
+    # @param [Hash] options
+    #   - `:score => Integer`: lower limit for getting by score
+    #   - `:rank  => Integer`: upper limit for getting by rank
+    #
+    # @return [Hash<String, Integer>] words with scores
+    def all(options = {})
+      words_with_scores = if score = options[:score]
+                            zrevrangebyscore('+inf', score, :withscores => true)
+                          else
+                            rank = options[:rank] || -1
+                            zrevrange(0, rank, :withscores => true)
+                          end
+
+      size = words_with_scores.size
+      index = 1
+
+      while index < size
+        words_with_scores[index] = words_with_scores[index].to_i
+        index += 2
+      end
+
+      Hash[*words_with_scores]
+    end
+
+    # Get score of a word.
+    #
+    # @param [String] a word
+    # @return [Integer, nil]
+    #   - when the word is member, score of the word
+    #   - when the word is not member, nil
+    def get(word)
+      score = zscore(word)
+      score ? score.to_i : nil
+    end
+    alias [] get
+
+    # Enhance the training data giving words.
+    #
+    # @param [Array<String>] words
+    def train(words)
+      @redis.pipelined do
+        increase = collect(words).inject(0) do |count, pair|
+          zincrby(pair[1], pair[0])
+          count + pair[1]
+        end
+
+        hincrby(name, increase) if increase > 0
+      end
+    end
+
+    # Attenuate the training data giving words.
+    #
+    # @param [Array<String>] words
+    def untrain(words)
+      decrease = 0
+
+      values = @redis.pipelined do
+        decrease = collect(words).inject(0) do |count, pair|
+          zincrby(-pair[1], pair[0])
+          count + pair[1]
+        end
+
+        zremrangebyscore('-inf', 0)
+      end
+
+      values[0..-2].each do |score|
+        score = score.to_i
+        decrease += score if score < 0
+      end
+
+      hincrby(name, -decrease) if decrease > 0
+    end
+
+    # Get total of scores.
+    #
+    # @return [Integer] total of scores
+    def size
+      (hget(name) || 0).to_i
+    end
+
+    # Get effectively scores for each word.
+    #
+    # @param [Array<String>] words
+    # @param [Hash<String, Integer>] words with scores prepared in advance for
+    #   reduce access to Redis
+    # @return [Array<Integer>] scores for each word
+    def scores(words, words_with_scores = {})
+      scores = @redis.pipelined do
+        words.each do |word|
+          zscore(word) unless words_with_scores[word]
+        end
+      end
+
+      index = 0
+
+      next_score = lambda do
+        score = scores[index]
+        index += 1
+        score ? score.to_i : nil
+      end
+
+      words.map { |word| words_with_scores[word] || next_score[] }
+    end
+
+    private
+
+    %w(zrevrange zrevrangebyscore zscore zincrby zremrangebyscore).each do |command|
+      define_method(command) do |*args|
+        @category_key ||= make_category_key(@name)
+        @redis.__send__(command, @category_key, *args)
+      end
+    end
+
+    def collect(words)
+      words.inject({}) do |hash, word|
+        hash[word] ||= 0
+        hash[word] += 1
+        hash
+      end
+    end
+  end
+end

data/lib/inferx/version.rb

@@ -0,0 +1,3 @@
+class Inferx
+  VERSION = '0.1.5'
+end

data/lib/inferx.rb

@@ -0,0 +1,56 @@
+require 'redis'
+
+require 'inferx/version'
+require 'inferx/categories'
+
+class Inferx
+
+  # @param [Hash] options
+  #   - `:namespace => String`: namespace of keys to be used to Redis
+  #
+  #   Other options are passed to Redis#initialize in:
+  #     https://github.com/redis/redis-rb
+  def initialize(options = {})
+    namespace = options.delete(:namespace)
+    redis = Redis.new(options)
+    @categories = Categories.new(redis, namespace)
+  end
+
+  attr_reader :categories
+
+  # Get a score of a category according to a set of words.
+  #
+  # @param [Inferx::Category] a category for scoring
+  # @param [Array<String>] a set of words
+  # @return [Float] a score of the category
+  def score(category, words)
+    size = category.size.to_f
+    return -Float::INFINITY unless size > 0
+    words_with_scores = category.all(:rank => 500)
+    scores = category.scores(words, words_with_scores)
+    scores.inject(0) { |s, score| s + Math.log((score || 0.1) / size) }
+  end
+
+  # Get a score for each category according to a set of words.
+  #
+  # @param [Array<String>] a set of words
+  # @return [Hash<Symbol, Float>] scores to key a category
+  #
+  # @see #score
+  def classifications(words)
+    words = words.uniq
+    Hash[@categories.map { |category| [category.name, score(category, words)] }]
+  end
+
+  # Classify words to any one category
+  #
+  # @param [Array<String>] a set of words
+  # @return [Symbol] most high-scoring category name
+  #
+  # @see #score
+  # @see #classifications
+  def classify(words)
+    category = classifications(words).max_by { |score| score[1] }
+    category ? category[0] : nil
+  end
+end

data/spec/inferx/adapter_spec.rb

@@ -0,0 +1,75 @@
+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
+
+  context 'with a namespace' do
+    it 'sets the namespace to @namespace' do
+      adapter = described_class.new(redis_stub, 'example')
+      adapter.instance_eval { @namespace }.should == 'example'
+    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 a namespace' do
+    it 'returns the key included the namespace' do
+      adapter = described_class.new(redis_stub, '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 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 a namespace' do
+    it 'returns the key included the namespace' do
+      adapter = described_class.new(redis_stub, '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, 'example')
+    klass = mock.tap { |m| m.should_receive(:new).with(redis, 'arg1', 'arg2', '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).and_return('klass') }
+    adapter.spawn(klass).should == 'klass'
+  end
+end

data/spec/inferx/categories_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require 'inferx/categories'
+
+describe Inferx::Categories do
+  it 'includes Enumerable' do
+    described_class.should be_include(Enumerable)
+  end
+end
+
+describe Inferx::Categories, '#initialize' do
+  it 'calls Inferx::Adapter#initialize' do
+    redis = redis_stub
+    categories = described_class.new(redis, 'example')
+    categories.instance_eval { @redis }.should == redis
+    categories.instance_eval { @namespace }.should == 'example'
+  end
+end
+
+describe Inferx::Categories, '#all' do
+  it 'calls Redis#hkeys' do
+    redis = redis_stub do |s|
+      s.should_receive(:hkeys).with('inferx:categories')
+    end
+
+    categories = described_class.new(redis)
+    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([])
+    end
+
+    categories = described_class.new(redis)
+    categories.all.should be_empty
+  end
+end
+
+describe Inferx::Categories, '#get' do
+  it 'calls Redis#hexists' do
+    redis = redis_stub do |s|
+      s.should_receive(:hexists).with('inferx:categories', :red).and_return(true)
+    end
+
+    categories = described_class.new(redis)
+    categories.get(:red)
+  end
+
+  it 'calles Inferx::Category.new with the instance of Redis, the category name and the namepsace' do
+    redis = redis_stub do |s|
+      s.stub!(:hexists).and_return(true)
+    end
+
+    Inferx::Category.should_receive(:new).with(redis, :red, 'example')
+    categories = described_class.new(redis, 'example')
+    categories.get(:red)
+  end
+
+  it 'returns an instance of Inferx::Category' do
+    redis = redis_stub do |s|
+      s.stub!(:hexists).and_return(true)
+    end
+
+    categories = described_class.new(redis)
+    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!(:hexists).and_return(false)
+      end
+
+      categories = described_class.new(redis)
+      lambda { categories.get(:red) }.should raise_error(ArgumentError, /'red' is missing/)
+    end
+  end
+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)
+    end
+
+    categories = described_class.new(redis)
+    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)
+    end
+
+    categories = described_class.new(redis)
+    categories.add(:red, :green)
+  end
+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(:del).with('inferx:categories:red')
+    end
+
+    categories = described_class.new(redis)
+    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(:del).with('inferx:categories:red', 'inferx:categories:green')
+    end
+
+    categories = described_class.new(redis)
+    categories.remove(:red, :green)
+  end
+end
+
+describe Inferx::Categories, '#each' do
+  before do
+    @redis = redis_stub do |s|
+      s.stub!(:hkeys).and_return(%w(red green blue))
+    end
+  end
+
+  it 'passes an instance of Inferx::Category to the block' do
+    categories = described_class.new(@redis)
+    categories.each { |category| category.should be_an(Inferx::Category) }
+  end
+
+  it 'calls the block according to the number of the categories' do
+    n = 0
+    categories = described_class.new(@redis)
+    categories.each { |category| n += 1 }
+    n.should == 3
+  end
+end

data/spec/inferx/category_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+require 'inferx/category'
+
+describe Inferx::Category, '#initialize' do
+  it 'calls Inferx::Adapter#initialize' do
+    redis = redis_stub
+    category = described_class.new(redis, :red, 'example')
+    category.instance_eval { @redis }.should == redis
+    category.instance_eval { @namespace }.should == 'example'
+  end
+
+  it 'sets the category name to the name attribute' do
+    category = described_class.new(redis_stub, :red)
+    category.name.should == :red
+  end
+end
+
+describe Inferx::Category, '#all' do
+  it 'calls Redis#revrange' do
+    redis = redis_stub do |s|
+      s.should_receive(:zrevrange).with('inferx:categories:red', 0, -1, :withscores => true).and_return([])
+    end
+
+    category = described_class.new(redis, :red)
+    category.all
+  end
+
+  it 'returns the words with the score' do
+    redis = redis_stub do |s|
+      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)
+    category.all.should == {'apple' => 2, 'strawberry' => 3}
+  end
+
+  context 'with the rank option' do
+    it 'calls Redis#zrevrange' do
+      redis = redis_stub do |s|
+        s.should_receive(:zrevrange).with('inferx:categories:red', 0, 1000, :withscores => true).and_return([])
+      end
+
+      category = described_class.new(redis, :red)
+      category.all(:rank => 1000)
+    end
+  end
+
+  context 'with the score option' do
+    it 'calls Redis#zrevrangebyscore' do
+      redis = redis_stub do |s|
+        s.should_receive(:zrevrangebyscore).with('inferx:categories:red', '+inf', 2, :withscores => true).and_return([])
+      end
+
+      category = described_class.new(redis, :red)
+      category.all(:score => 2)
+    end
+  end
+end
+
+describe Inferx::Category, '#get' do
+  it 'calls Redis#zscore' do
+    redis = redis_stub do |s|
+      s.should_receive(:zscore).with('inferx:categories:red', 'apple')
+    end
+
+    category = described_class.new(redis, :red)
+    category.get('apple')
+  end
+
+  it 'returns the score as Integer' do
+    redis = redis_stub do |s|
+      s.stub!(:zscore).with('inferx:categories:red', 'apple').and_return('1')
+    end
+
+    category = described_class.new(redis, :red)
+    category.get('apple').should == 1
+  end
+
+  context 'with a missing word' do
+    it 'returns nil' do
+      redis = redis_stub do |s|
+        s.stub!(:zscore).with('inferx:categories:red', 'strawberry').and_return(nil)
+      end
+
+      category = described_class.new(redis, :red)
+      category.get('strawberry').should be_nil
+    end
+  end
+end
+
+describe Inferx::Category, '#train' do
+  it 'calls Redis#zincrby and Redis#hincrby' 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)
+    end
+
+    category = described_class.new(redis, :red)
+    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)
+      end
+
+      category = described_class.new(redis, :red)
+      category.train(%w())
+    end
+  end
+end
+
+describe Inferx::Category, '#untrain' do
+  it 'calls Redis#zincrby, Redis#zremrangebyscore and Redis#hincrby' 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(:zremrangebyscore).with('inferx:categories:red', '-inf', 0).and_return(%w(3 -2 1))
+      s.should_receive(:hincrby).with('inferx:categories', :red, -3)
+    end
+
+    category = described_class.new(redis, :red)
+    category.untrain(%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.stub!(:zincrby)
+        s.stub!(:zremrangebyscore).and_return(%w(-2 -3 2))
+        s.should_not_receive(:hincrby)
+      end
+
+      category = described_class.new(redis, :red)
+      category.untrain(%w(apple strawberry apple strawberry strawberry))
+    end
+  end
+end
+
+describe Inferx::Category, '#size' do
+  it 'calls Redis#hget' do
+    redis = redis_stub do |s|
+      s.should_receive(:hget).with('inferx:categories', :red)
+    end
+
+    category = described_class.new(redis, :red)
+    category.size
+  end
+
+  it 'returns total of the score of the words as Integer' do
+    redis = redis_stub do |s|
+      s.stub!(:hget).and_return('1')
+    end
+
+    category = described_class.new(redis, :red)
+    category.size.should == 1
+  end
+
+  context 'with the missing key' do
+    it 'returns 0' do
+      redis = redis_stub do |s|
+        s.stub!(:hget).and_return(nil)
+      end
+
+      category = described_class.new(redis, :red)
+      category.size.should == 0
+    end
+  end
+end
+
+describe Inferx::Category, '#scores' do
+  it 'calls Redis#zscore' do
+    redis = redis_stub do |s|
+      s.should_receive(:zscore).with('inferx:categories:red', 'apple')
+      s.should_receive(:zscore).with('inferx:categories:red', 'strawberry')
+    end
+
+    category = described_class.new(redis, :red)
+    category.scores(%w(apple strawberry))
+  end
+
+  it 'returns the scores' do
+    redis = redis_stub do |s|
+      s.stub!(:pipelined).and_return(%w(2 3))
+    end
+
+    category = described_class.new(redis, :red)
+    scores = category.scores(%w(apple strawberry))
+    scores.should == [2, 3]
+  end
+
+  context 'with words with scores' do
+    it 'returns the scores to use the cache' do
+      redis = redis_stub do |s|
+        s.should_not_receive(:zscore).with('inferx:categories:red', 'strawberry')
+        s.stub!(:pipelined).and_return { |&block| block.call; [2] }
+      end
+
+      category = described_class.new(redis, :red)
+      scores = category.scores(%w(apple strawberry), 'strawberry' => 3, 'hoge' => 1)
+      scores.should == [2, 3]
+    end
+  end
+end

data/spec/inferx_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'inferx'
+
+describe Inferx do
+  it 'is an instance of Class' do
+    described_class.should be_an_instance_of(Class)
+  end
+
+  it 'has VERSION constant' do
+    described_class.should be_const_defined(:VERSION)
+  end
+end
+
+describe Inferx, '#initialize' do
+  it "calls #{described_class}::Categories.new with a connection of Redis and the namespace option" do
+    redis = redis_stub
+    Inferx::Categories.should_receive(:new).with(redis, 'example')
+    described_class.new(:namespace => 'example')
+  end
+
+  it "sets an instance of #{described_class}::Categories to the categories attribute" do
+    redis_stub
+    inferx = described_class.new
+    inferx.categories.should be_an(Inferx::Categories)
+  end
+end
+
+describe Inferx, '#score' do
+  before do
+    @inferx = described_class.new
+  end
+
+  it "calls #{described_class}::Categories#size, #{described_class}::Category#all and #{described_class}::Category#scores" do
+    category = mock.tap do |m|
+      m.should_receive(:size).and_return(5)
+      m.should_receive(:all).with(:rank => 500).and_return('apple' => 2)
+      m.should_receive(:scores).with(%w(apple), 'apple' => 2).and_return([2])
+    end
+
+    @inferx.score(category, %w(apple))
+  end
+
+  it 'returns an expected score' do
+    {
+      [%w(apple), 2, [2]]   =>  0.0,
+      [%w(apple), 2, [nil]] => -2.995732273553991,
+      [%w(apple), 3, [nil]] => -3.4011973816621555
+    }.each do |args, expected|
+      words, size, scores = args
+
+      category = stub.tap do |s|
+        s.stub!(:size).and_return(size)
+        s.stub!(:scores).and_return(scores)
+        s.stub!(:all)
+      end
+
+      @inferx.score(category, words).should == expected
+    end
+  end
+
+  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)
+    end
+
+    score = @inferx.score(category, %w(apple))
+    score.should be_infinite
+    score.should < 0
+  end
+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) }
+    end
+
+    @inferx = described_class.new.tap do |s|
+      s.instance_eval { @categories = categories }
+      s.stub!(:score).and_return { |category, words| "score of #{category.name}" }
+    end
+  end
+
+  it "calls #{described_class}#score" do
+    @inferx.tap do |m|
+      m.should_receive(:score).with(@inferx.categories[0], %w(apple))
+      m.should_receive(:score).with(@inferx.categories[1], %w(apple))
+      m.should_receive(:score).with(@inferx.categories[2], %w(apple))
+    end
+
+    @inferx.classifications(%w(apple))
+  end
+
+  it 'calls uniq method of the words' do
+    words = %w(apple).tap do |m|
+      m.should_receive(:uniq).and_return(m)
+    end
+
+    @inferx.classifications(words)
+  end
+
+  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'
+    }
+  end
+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)
+    end
+  end
+
+  it "calls #{described_class}#classifications" do
+    @inferx.tap do |m|
+      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
+  end
+
+  it 'returns nil if the categories is nothing' do
+    @inferx.tap do |s|
+      s.stub!(:classifications).and_return({})
+    end
+
+    @inferx.classify(%w(apple)).should be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+def redis_stub
+  stub.tap do |s|
+    s.stub!(:pipelined).and_return { |&block| block.call }
+    yield s if block_given?
+    Redis.stub!(:new).and_return(s) if defined? Redis
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: inferx
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+  prerelease: 
+platform: ruby
+authors:
+- Takahiro Kondo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: It is Naive Bayes classifier, and the training data is kept always by
+  Redis.
+email:
+- kondo@atedesign.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- inferx.gemspec
+- lib/inferx.rb
+- lib/inferx/adapter.rb
+- lib/inferx/categories.rb
+- lib/inferx/category.rb
+- lib/inferx/version.rb
+- spec/inferx/adapter_spec.rb
+- spec/inferx/categories_spec.rb
+- spec/inferx/category_spec.rb
+- spec/inferx_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Naive Bayes classifier, the training data on Redis
+test_files:
+- spec/inferx/adapter_spec.rb
+- spec/inferx/categories_spec.rb
+- spec/inferx/category_spec.rb
+- spec/inferx_spec.rb
+- spec/spec_helper.rb