natto 0.9.0 → 0.9.1

data/CHANGELOG

@@ -1,14 +1,17 @@
 ## CHANGELOG
 
-- __2011/09/11: 0.9.0 release.
-    - Bumping up version to 0.9.0, as natto appears to be stable.
-    - Also migrated project to github.
+- __2011/10/23__: 0.9.1 release.
+    - MeCab configurations can now be a string as per MeCab command-line
+    - Adding more tests around the configuration processing
+    - Pulling support for mecab option 'output', since it is more of a command-line feature
+
+- __2011/09/11__: 0.9.0 release.
+    - Bumping up version to 0.9.0, as natto appears to be stable
+    - Also migrated project to github
 
 - __2011/03/23__: 0.5.1 release.
-    - Corrected mojibake issue for surface and feature values 
-      when node-parsing.
-    - Corrected call to NBest initializer in lambdas 
-      for Natto::MeCab#initialize.
+    - Corrected mojibake issue for surface and feature values when node-parsing
+    - Corrected call to NBest initializer in lambdas for Natto::MeCab#initialize
 
 - __2011/02/26__: 0.5.0 release.
     - Added support for node parsing using blocks
@@ -73,6 +76,6 @@
     - Continuing development on proper resource deallocation
     - Adding options hash in object initializer 
 
-- __2010/12/13__: Released version 0.0.1. The objective is to provide
-  an easy-to-use, production-level Ruby binding to MeCab.
+- __2010/12/13__: Released version 0.0.1. 
     - Initial release 
+    - The objective is to provide an easy-to-use, production-level Ruby binding to MeCab

data/README.md

@@ -8,8 +8,6 @@ natto is a gem bridging Ruby and MeCab using FFI (foreign function interface). N
 
 You can learn more about [natto at github](https://github.com/buruzaemon/natto).
 
-Comments and questions are welcome at the [natto-users Group](http://groups.google.com/group/natto-users).
-
 ## Requirements
 natto requires the following:
 
@@ -76,7 +74,7 @@ e.g., from within a Ruby program
 
 ## Contributing to natto
 -  Use [git](http://git-scm.com/) and [check out the latest code at github](https://github.com/buruzaemon/natto) to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
--  [Browse out the issue tracker](https://github.com/buruzaemon/natto/issues) to make sure someone already hasn't requested it and/or contributed it.
+-  [Browse the issue tracker](https://github.com/buruzaemon/natto/issues) to make sure someone already hasn't requested it and/or contributed it.
 -  Fork the project.
 -  Start a feature/bugfix branch.
 -  Commit and push until you are happy with your contribution.

data/lib/natto.rb

@@ -7,7 +7,8 @@ module Natto
   require 'ffi'
 
   # <tt>MeCab</tt> is a wrapper class for the <tt>mecab</tt> parser.
-  # Options to the <tt>mecab</tt> parser are passed in as a hash at
+  # Options to the <tt>mecab</tt> parser are passed in as a string
+  # (MeCab command-line style) or as a Ruby-style hash at
   # initialization.
   #
   # <h2>Usage</h2>
@@ -15,7 +16,7 @@ module Natto
   #     require 'rubygems' if RUBY_VERSION.to_f < 1.9
   #     require 'natto'
   #
-  #     nm = Natto::MeCab.new(:output_format_type=>'chasen2')
+  #     nm = Natto::MeCab.new('-O chasen2')
   #     => #<Natto::MeCab:0x28d3bdc8 \
   #          @ptr=#<FFI::Pointer address=0x28afb980>, \
   #          @options={:output_format_type=>"chasen2"}, \
@@ -40,16 +41,28 @@ module Natto
 
     attr_reader :options, :dicts, :version
 
-    # Supported options to the <tt>mecab</tt> parser.
+    # Mapping of mecab short-style configuration options to the <tt>mecab</tt> parser.
     # See the <tt>mecab</tt> help for more details. 
-    SUPPORTED_OPTS = [ :rcfile, :dicdir, :userdic, :lattice_level, :all_morphs,
-                       :output_format_type, :node_format, :unk_format, 
-                       :bos_format, :eos_format, :eon_format, :unk_feature, 
-                       :input_buffer_size, :allocate_sentence, :nbest, :theta, 
-                       :cost_factor, :output ].freeze
+    SUPPORTED_OPTS = { '-r' => :rcfile, 
+                       '-d' => :dicdir, 
+                       '-u' => :userdic, 
+                       '-l' => :lattice_level, 
+                       '-a' => :all_morphs,
+                       '-O' => :output_format_type, 
+                       '-F' => :node_format, 
+                       '-U' => :unk_format,
+                       '-B' => :bos_format, 
+                       '-E' => :eos_format, 
+                       '-S' => :eon_format, 
+                       '-x' => :unk_feature, 
+                       '-b' => :input_buffer_size, 
+                       '-C' => :allocate_sentence, 
+                       '-N' => :nbest, 
+                       '-t' => :theta, 
+                       '-c' => :cost_factor }.freeze
 
     # Initializes the wrapped <tt>mecab</tt> instance with the
-    # given <tt>options</tt> hash.
+    # given <tt>options</tt>.
     # 
     # Options supported are:
     #
@@ -70,8 +83,9 @@ module Natto
     # - :nbest --  output N best results (integer, default 1), requires lattice level >= 1
     # - :theta --  temperature parameter theta (float, default 0.75)
     # - :cost_factor --  cost factor (integer, default 700)
-    # - :output -- set the output file name
     # 
+    # <p>MeCab command-line arguments (-F) or long (--node-format) may be used in 
+    # addition to Ruby-style <code>Hash</code>es</p>
     # <i>Use single-quotes to preserve format options that contain escape chars.</i><br/>
     # e.g.<br/>
     #
@@ -95,11 +109,12 @@ module Natto
     #     EOS
     #     => nil
     #
-    # @param [Hash]
+    # @param [Hash or String]
     # @raise [MeCabError] if <tt>mecab</tt> cannot be initialized with the given <tt>options</tt>
     # @see MeCab::SUPPORTED_OPTS
     def initialize(options={})
-      @options = {}.merge(options)
+      @options = self.class.parse_mecab_options(options) 
+          
       @dicts = []
 
       opt_str = self.class.build_options_str(@options)
@@ -107,8 +122,8 @@ module Natto
       raise MeCabError.new("Could not initialize MeCab with options: '#{opt_str}'") if @ptr.address == 0x0
 
       # set mecab parsing options
-      self.mecab_set_theta(@ptr, @options[:theta].to_f) if @options[:theta]
-      self.mecab_set_lattice_level(@ptr, @options[:lattice_level].to_i) if @options[:lattice_level]
+      self.mecab_set_theta(@ptr, @options[:theta]) if @options[:theta]
+      self.mecab_set_lattice_level(@ptr, @options[:lattice_level]) if @options[:lattice_level]
       self.mecab_set_all_morphs(@ptr, 1) if @options[:all_morphs]
        
       # Set mecab parsing implementations for N-best and regular parsing,
@@ -192,7 +207,7 @@ module Natto
     #
     # @return [String] encoded object id, FFI pointer, options hash, list of dictionaries, and MeCab version
     def to_s
-      %(#{super.chop} @ptr=#{@ptr.to_s}, @options=#{@options.to_s}, @dicts=#{@dicts.to_s}, @version="#{@version.to_s}">)
+      %(#{super.chop} @ptr=#{@ptr.to_s}, @options=#{@options.inspect}, @dicts=#{@dicts.to_s}, @version="#{@version.to_s}">)
     end
 
     # Overrides <tt>Object#inspect</tt>.
@@ -217,6 +232,71 @@ module Natto
       end
     end
 
+    # Prepares and returns a hash mapping symbols for
+    # the specified, recognized MeCab options, and their
+    # values. Will parse and convert string (short or
+    # long argument styles) or hash. 
+    def self.parse_mecab_options(options={})
+      h = {}
+      if options.is_a? String
+        tokens = options.split
+        t = tokens.shift
+        while t
+          if SUPPORTED_OPTS[t]
+            k = SUPPORTED_OPTS[t]
+            if [ :all_morphs, :allocate_sentence ].include?(k) 
+              h[k] = true
+            else
+              v = tokens.shift
+              if [:lattice_level, :input_buffer_size, :nbest, :cost_factor ].include?(k)
+                h[k] = v.to_i 
+              elsif k == :theta
+                h[k] = v.to_f
+              else 
+                h[k] = v
+              end
+            end
+          elsif t.start_with?('--') 
+            k = t.split('--').last
+            if k.include?('=')
+              k,v = k.split('=')
+              k = k.gsub('-','_').to_sym
+              if SUPPORTED_OPTS.values.include?(k)
+                if [:lattice_level, :input_buffer_size, :nbest, :cost_factor ].include?(k)
+                  h[k] = v.to_i 
+                elsif k == :theta
+                  h[k] = v.to_f
+                else 
+                  h[k] = v
+                end
+              end
+            elsif %w( all-morphs allocate-sentence ).include?(k)
+              h[k.gsub('-','_').to_sym] = true
+            end
+          end
+          t = tokens.shift
+        end 
+      else
+        SUPPORTED_OPTS.values.each do |k|
+          if options.has_key?(k)
+            if [ :all_morphs, :allocate_sentence ].include?(k) 
+              h[k] = true
+            else
+              v = options[k]  
+              if [ :lattice_level, :input_buffer_size, :nbest, :cost_factor ].include?(k)
+                h[k] = v.to_i 
+              elsif k == :theta
+                h[k] = v.to_f
+              else 
+                h[k] = v
+              end
+            end
+          end
+        end
+      end
+      h
+    end
+
     # Returns a string-representation of the options to
     # be passed in the construction of <tt>mecab</tt>.
     #
@@ -224,10 +304,9 @@ module Natto
     # @return [String] representation of the options to the <tt>mecab</tt> parser
     def self.build_options_str(options={})
       opt = []
-      SUPPORTED_OPTS.each do |k|
+      SUPPORTED_OPTS.values.each do |k|
         if options.has_key? k
           key = k.to_s.gsub('_', '-')  
-          # all-morphs and allocate-sentence are just flags
           if %w( all-morphs allocate-sentence ).include? key
             opt << "--#{key}" if options[k]==true
           else

data/lib/natto/version.rb

@@ -23,5 +23,5 @@
 # which are made available via <tt>FFI</tt> bindings to <tt>mecab</tt>.
 module Natto
   # Version string for this Rubygem.
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

data/test/natto/tc_mecab.rb

@@ -22,70 +22,97 @@ class TestMeCab < Test::Unit::TestCase
     @m = nil
   end
 
-  # Tests the Natto::MeCab.build_options_str function.
-  def test_build_options_str
-    res = Natto::MeCab.build_options_str
-    assert_equal('', res)
-
-    res = Natto::MeCab.build_options_str(:unknown=>"ignore")
-    assert_equal('', res)
-
-    res = Natto::MeCab.build_options_str(:rcfile=>"/some/file")
-    assert_equal('--rcfile=/some/file', res)
-
-    res = Natto::MeCab.build_options_str(:dicdir=>"/some/other/file")
-    assert_equal('--dicdir=/some/other/file', res)
-
-    res = Natto::MeCab.build_options_str(:userdic=>"/yet/another/file")
-    assert_equal('--userdic=/yet/another/file', res)
-
-    res = Natto::MeCab.build_options_str(:lattice_level=>42)
-    assert_equal('--lattice-level=42', res)
-
-    res = Natto::MeCab.build_options_str(:all_morphs=>true)
-    assert_equal('--all-morphs', res)
-
-    res = Natto::MeCab.build_options_str(:output_format_type=>"natto")
-    assert_equal('--output-format-type=natto', res)
+  def test_parse_mecab_options
+    assert_equal({:rcfile => '/some/file'}, Natto::MeCab.parse_mecab_options('-r /some/file'))
+    assert_equal({:rcfile => '/some/file'}, Natto::MeCab.parse_mecab_options('--rcfile=/some/file'))
+    assert_equal({:rcfile => '/some/file'}, Natto::MeCab.parse_mecab_options(:rcfile=>"/some/file"))
     
-    res = Natto::MeCab.build_options_str(:node_format=>'%m\t%f[7]\n')
-    assert_equal('--node-format=%m\t%f[7]\n', res)
+    assert_equal({:dicdir => '/some/other/file'}, Natto::MeCab.parse_mecab_options('-d /some/other/file'))
+    assert_equal({:dicdir => '/some/other/file'}, Natto::MeCab.parse_mecab_options('--dicdir=/some/other/file'))
+    assert_equal({:dicdir => '/some/other/file'}, Natto::MeCab.parse_mecab_options(:dicdir=>"/some/other/file"))
     
-    res = Natto::MeCab.build_options_str(:unk_format=>'%m\t%f[7]\n')
-    assert_equal('--unk-format=%m\t%f[7]\n', res)
-
-    res = Natto::MeCab.build_options_str(:bos_format=>'%m\t%f[7]\n')
-    assert_equal('--bos-format=%m\t%f[7]\n', res)
-
-    res = Natto::MeCab.build_options_str(:eos_format=>'%m\t%f[7]\n')
-    assert_equal('--eos-format=%m\t%f[7]\n', res)
-
-    res = Natto::MeCab.build_options_str(:eon_format=>'%m\t%f[7]\n')
-    assert_equal('--eon-format=%m\t%f[7]\n', res)
-
-    res = Natto::MeCab.build_options_str(:unk_feature=>'%m\t%f[7]\n')
-    assert_equal('--unk-feature=%m\t%f[7]\n', res)
-
-    res = Natto::MeCab.build_options_str(:input_buffer_size=>102400)
-    assert_equal('--input-buffer-size=102400', res)
-
-    res = Natto::MeCab.build_options_str(:allocate_sentence=>true)
-    assert_equal('--allocate-sentence', res)
-
-    res = Natto::MeCab.build_options_str(:nbest=>42)
-    assert_equal('--nbest=42', res)
+    assert_equal({:userdic => '/yet/another/file'}, Natto::MeCab.parse_mecab_options('-u /yet/another/file'))
+    assert_equal({:userdic => '/yet/another/file'}, Natto::MeCab.parse_mecab_options('--userdic=/yet/another/file'))
+    assert_equal({:userdic => '/yet/another/file'}, Natto::MeCab.parse_mecab_options(:userdic=>"/yet/another/file"))
+    
+    assert_equal({:lattice_level => 42}, Natto::MeCab.parse_mecab_options('-l 42'))
+    assert_equal({:lattice_level => 42}, Natto::MeCab.parse_mecab_options('--lattice-level=42'))
+    assert_equal({:lattice_level => 42}, Natto::MeCab.parse_mecab_options(:lattice_level=>42))
+    
+    assert_equal({:all_morphs => true}, Natto::MeCab.parse_mecab_options('-a'))
+    assert_equal({:all_morphs => true}, Natto::MeCab.parse_mecab_options('--all-morphs'))
+    assert_equal({:all_morphs => true}, Natto::MeCab.parse_mecab_options(:all_morphs=>true))
+    
+    assert_equal({:output_format_type => 'natto'}, Natto::MeCab.parse_mecab_options('-O natto'))
+    assert_equal({:output_format_type => 'natto'}, Natto::MeCab.parse_mecab_options('--output-format-type=natto'))
+    assert_equal({:output_format_type => 'natto'}, Natto::MeCab.parse_mecab_options(:output_format_type=>"natto"))
+    
+    assert_equal({:node_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('-F %m\t%f[7]\n'))
+    assert_equal({:node_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('--node-format=%m\t%f[7]\n'))
+    assert_equal({:node_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(:node_format=>'%m\t%f[7]\n'))
+    
+    assert_equal({:unk_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('-U %m\t%f[7]\n'))
+    assert_equal({:unk_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('--unk-format=%m\t%f[7]\n'))
+    assert_equal({:unk_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(:unk_format=>'%m\t%f[7]\n'))
+    
+    assert_equal({:bos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('-B %m\t%f[7]\n'))
+    assert_equal({:bos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('--bos-format=%m\t%f[7]\n'))
+    assert_equal({:bos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(:bos_format=>'%m\t%f[7]\n'))
+    
+    assert_equal({:eos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('-E %m\t%f[7]\n'))
+    assert_equal({:eos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('--eos-format=%m\t%f[7]\n'))
+    assert_equal({:eos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(:eos_format=>'%m\t%f[7]\n'))
+    
+    assert_equal({:eon_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('-S %m\t%f[7]\n'))
+    assert_equal({:eon_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('--eon-format=%m\t%f[7]\n'))
+    assert_equal({:eon_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(:eon_format=>'%m\t%f[7]\n'))
+    
+    assert_equal({:unk_feature => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('-x %m\t%f[7]\n'))
+    assert_equal({:unk_feature => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options('--unk-feature=%m\t%f[7]\n'))
+    assert_equal({:unk_feature => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(:unk_feature=>'%m\t%f[7]\n'))
+    
+    assert_equal({:input_buffer_size => 102400}, Natto::MeCab.parse_mecab_options('-b 102400'))
+    assert_equal({:input_buffer_size => 102400}, Natto::MeCab.parse_mecab_options('--input-buffer-size=102400'))
+    assert_equal({:input_buffer_size => 102400}, Natto::MeCab.parse_mecab_options(:input_buffer_size=>102400))
+    
+    assert_equal({:allocate_sentence => true}, Natto::MeCab.parse_mecab_options('-C'))
+    assert_equal({:allocate_sentence => true}, Natto::MeCab.parse_mecab_options('--allocate-sentence'))
+    assert_equal({:allocate_sentence => true}, Natto::MeCab.parse_mecab_options(:allocate_sentence=>true))
+    
+    assert_equal({:nbest => 42}, Natto::MeCab.parse_mecab_options('-N 42'))
+    assert_equal({:nbest => 42}, Natto::MeCab.parse_mecab_options('--nbest=42'))
+    assert_equal({:nbest => 42}, Natto::MeCab.parse_mecab_options(:nbest=>42))
+    
+    assert_equal({:theta => 0.42}, Natto::MeCab.parse_mecab_options('-t 0.42'))
+    assert_equal({:theta => 0.42}, Natto::MeCab.parse_mecab_options('--theta=0.42'))
+    assert_equal({:theta => 0.42}, Natto::MeCab.parse_mecab_options(:theta=>0.42))
+    
+    assert_equal({:cost_factor => 42}, Natto::MeCab.parse_mecab_options('-c 42'))
+    assert_equal({:cost_factor => 42}, Natto::MeCab.parse_mecab_options('--cost-factor=42'))
+    assert_equal({:cost_factor => 42}, Natto::MeCab.parse_mecab_options(:cost_factor=>42))
 
-    res = Natto::MeCab.build_options_str(:theta=>0.42)
-    assert_equal('--theta=0.42', res)
+    assert_equal({}, Natto::MeCab.parse_mecab_options)
+    assert_equal({}, Natto::MeCab.parse_mecab_options(:unknown=>"ignore"))
+  end
 
-    res = Natto::MeCab.build_options_str(:cost_factor=>42)
-    assert_equal('--cost-factor=42', res)
-    
-    res = Natto::MeCab.build_options_str(:output_format_type=>"natto", 
-                                         :userdic=>"/some/file", 
-                                         :dicdir=>"/some/other/file",
-                                         :all_morphs=>true)
-    assert_equal('--dicdir=/some/other/file --userdic=/some/file --all-morphs --output-format-type=natto', res)
+  def test_build_options_str
+    assert_equal('--rcfile=/some/file', Natto::MeCab.build_options_str(:rcfile=>"/some/file"))
+    assert_equal('--dicdir=/some/other/file', Natto::MeCab.build_options_str(:dicdir=>"/some/other/file"))
+    assert_equal('--userdic=/yet/another/file', Natto::MeCab.build_options_str(:userdic=>"/yet/another/file"))
+    assert_equal('--lattice-level=42', Natto::MeCab.build_options_str(:lattice_level=>42))
+    assert_equal('--all-morphs', Natto::MeCab.build_options_str(:all_morphs=>true))
+    assert_equal('--output-format-type=natto', Natto::MeCab.build_options_str(:output_format_type=>"natto"))
+    assert_equal('--node-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:node_format=>'%m\t%f[7]\n'))
+    assert_equal('--unk-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:unk_format=>'%m\t%f[7]\n'))
+    assert_equal('--bos-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:bos_format=>'%m\t%f[7]\n'))
+    assert_equal('--eos-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:eos_format=>'%m\t%f[7]\n'))
+    assert_equal('--eon-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:eon_format=>'%m\t%f[7]\n'))
+    assert_equal('--unk-feature=%m\t%f[7]\n', Natto::MeCab.build_options_str(:unk_feature=>'%m\t%f[7]\n'))
+    assert_equal('--input-buffer-size=102400',Natto::MeCab.build_options_str(:input_buffer_size=>102400))
+    assert_equal('--allocate-sentence', Natto::MeCab.build_options_str(:allocate_sentence=>true))
+    assert_equal('--nbest=42', Natto::MeCab.build_options_str(:nbest=>42))
+    assert_equal('--theta=0.42', Natto::MeCab.build_options_str(:theta=>0.42))
+    assert_equal('--cost-factor=42', Natto::MeCab.build_options_str(:cost_factor=>42))
   end
 
   # Tests the construction and initial state of a Natto::MeCab instance.
@@ -101,18 +128,42 @@ class TestMeCab < Test::Unit::TestCase
       m = Natto::MeCab.new(opts)
     end
     assert_equal(opts, m.options)
+    assert_nothing_raised do
+      m = Natto::MeCab.new("-O chasen")
+    end
+    assert_equal(opts, m.options)
+    assert_nothing_raised do
+      m = Natto::MeCab.new("--output-format-type=chasen")
+    end
+    assert_equal(opts, m.options)
     
     opts = {:all_morphs=>true, :allocate_sentence=>true}
     assert_nothing_raised do
       m = Natto::MeCab.new(opts)
     end
     assert_equal(opts, m.options)
+    assert_nothing_raised do
+      m = Natto::MeCab.new('-a -C')
+    end
+    assert_equal(opts, m.options)
+    assert_nothing_raised do
+      m = Natto::MeCab.new('--all-morphs --allocate-sentence')
+    end
+    assert_equal(opts, m.options)
     
     opts = {:lattice_level=>999}
     assert_nothing_raised do
       m = Natto::MeCab.new(opts)
     end
     assert_equal(opts, m.options)
+    assert_nothing_raised do
+      m = Natto::MeCab.new('-l 999')
+    end
+    assert_equal(opts, m.options)
+    assert_nothing_raised do
+      m = Natto::MeCab.new('--lattice-level=999')
+    end
+    assert_equal(opts, m.options)
   end
 
   # Tests the initialize method for error cases for erroneous mecab options.

data/test/test_natto.rb

@@ -9,4 +9,4 @@ require 'natto'
   '/test/natto/tc_dictionaryinfo.rb',
   '/test/natto/tc_binding.rb' ].each do |tc|
   require File.join(File.expand_path('.'), tc)
-end
+  end

metadata

@@ -2,7 +2,7 @@
 name: natto
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
   - Brooke M. Fujita
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-11 00:00:00 +09:00
+date: 2011-10-23 00:00:00 +09:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency