natto 0.9.4 → 0.9.5

data/CHANGELOG

@@ -1,5 +1,14 @@
 ## CHANGELOG
 
+- __2012/09/16__: 0.9.5 release.
+    - Fixed [Issue 9: trimされていない文字列のparse](https://bitbucket.org/buruzaemon/natto/issue/9/trim-parse) 
+    - Fixed [Issue 10: BUG Segmentation Fault](https://bitbucket.org/buruzaemon/natto/issue/10/bug-segmentation-fault) 
+    - Adding parse_as_nodes to allow for method-chaining on list of parsed nodes
+    - Adding parse_as_strings to allow for method-chaining on list of string output
+    - Deprecating both readnodes and readlines (badly named methods, see parse_as_nodes and parse_as_strings, respectively)
+    - Refactored the option parsing logic into Natto::OptionParse
+    - Enhanced Natto::DictionaryInfo#type override for java or ruby < 1.9
+
 - __2012/02/26__: 0.9.4 release.
     - Exposing the underlying FFI pointer as @tagger in Natto::MeCab
     - Exposing the underlying FFI pointer as @pointer in Natto::MeCabNode

data/README.md

@@ -11,7 +11,7 @@ You can learn more about [natto at bitbucket](https://bitbucket.org/buruzaemon/n
 ## Requirements
 natto requires the following:
 
--  [MeCab _0.993_](http://code.google.com/p/mecab/downloads/list)
+-  [MeCab _0.994_](http://code.google.com/p/mecab/downloads/list)
 -  [ffi _0.6.3 or greater_](http://rubygems.org/gems/ffi)
 -  Ruby _1.8.7 or greater_
 
@@ -20,16 +20,16 @@ Install natto with the following gem command:
 
     gem install natto
 
-This will automatically install the [ffi](http://rubygems.org/gems/ffi) rubygem, which is what natto uses to bind to the <tt>mecab</tt> library.
+This will automatically install the [ffi](http://rubygems.org/gems/ffi) rubygem, which natto uses to bind to the <tt>mecab</tt> library.
 
 ## Installation on Windows 
-However, if you are using a CRuby on Windows, then you will first need to install the [RubyInstaller Development Kit (DevKit)](https://github.com/oneclick/rubyinstaller/wiki/Development-Kit), which is a MSYS/MinGW based toolkit than enables your Windows Ruby installation to build many of the native C/C++ extensions available, including <tt>ffi</tt>.
+However, if you are using a CRuby on Windows, then you will first need to install the [RubyInstaller Development Kit (DevKit)](https://github.com/oneclick/rubyinstaller/wiki/Development-Kit), a MSYS/MinGW based toolkit than enables your Windows Ruby installation to build many of the native C/C++ extensions available, including <tt>ffi</tt>.
 
 1. Download the latest release for RubyInstaller for Windows platforms and the corresponding DevKit from the [RubyInstaller for Windows downloads page](http://rubyinstaller.org/downloads/).
 2. After installing RubyInstaller for Windows, double-click on the DevKit-tdm installer <tt>.exe</tt>, and expand the contents to an appropriate location, for example <tt>C:\devkit</tt>.
 3. Open a command window under <tt>C:\devkit</tt>, and execute: <tt>ruby dk.rb init</tt>. This will locate all known ruby installations, and add them to <tt>C:\devkit\config.yml</tt>.
-4. Next, execute: <tt>ruby dk.rb install</tt>, which will add the DevKit to all of the installed rubies listed in your <tt>C:\devkit\config.yml</tt>.
-5. Now you should be able to install and build the <tt>ffi</tt> rubygem correctly on your Windows-installed ruby, so you can install <tt>natto with</tt>: 
+4. Next, execute: <tt>ruby dk.rb install</tt>, which will add the DevKit to all of the installed rubies listed in your <tt>C:\devkit\config.yml</tt>. Now you should be able to install and build the <tt>ffi</tt> rubygem correctly on your Windows-installed ruby. 
+5. Install <tt>natto</tt> with: 
 
     gem install natto
 
@@ -65,10 +65,10 @@ e.g., from within a Ruby program
                  type="0", \
                  filename="/usr/local/lib/mecab/dic/ipadic/sys.dic", \
                  charset="utf8">], \
-         @version="0.993">
+         @version="0.994">
 
     puts nm.version
-    => "0.993" 
+    => "0.994" 
 
     sysdic = nm.dicts.first
 

data/lib/natto.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
 require 'rubygems' if RUBY_VERSION.to_f < 1.9
 require 'natto/binding'
+require 'natto/option_parse'
 require 'natto/utils'
 
 module Natto 
   require 'ffi'
-  require 'optparse'
 
   # <tt>MeCab</tt> is a wrapper class for the <tt>mecab</tt> tagger.
   # Options to the <tt>mecab</tt> tagger are passed in as a string
@@ -20,12 +20,12 @@ module Natto
   #     nm = Natto::MeCab.new('-Ochasen')
   #     => #<Natto::MeCab:0x28d3bdc8 \
   #          @tagger=#<FFI::Pointer address=0x28afb980>, \
-  #          @options={:output_format_type=>"chasen"},  \
+  #          @options={:output_format_type=>"chasen"},   \
   #          @dicts=[#<Natto::DictionaryInfo:0x289a1f14  \
   #                    type="0", \
   #                    filename="/usr/local/lib/mecab/dic/ipadic/sys.dic", \
   #                    charset="utf8">], \
-  #          @version="0.993">
+  #          @version="0.994">
   #
   #     nm.parse('凡人にしか見えねえ風景ってのがあるんだよ。') do |n| 
   #       puts "#{n.surface}\t#{n.feature}" 
@@ -48,30 +48,11 @@ module Natto
   #
   class MeCab
     include Natto::Binding
+    include Natto::OptionParse
     include Natto::Utils
 
     attr_reader :tagger, :options, :dicts, :version
 
-    # Mapping of mecab short-style configuration options to the <tt>mecab</tt> tagger.
-    # See the <tt>mecab</tt> help for more details. 
-    SUPPORTED_OPTS = { '-r' => :rcfile, 
-                       '-d' => :dicdir, 
-                       '-u' => :userdic, 
-                       '-l' => :lattice_level, 
-                       '-O' => :output_format_type, 
-                       '-a' => :all_morphs,
-                       '-N' => :nbest, 
-                       '-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, 
-                       '-t' => :theta, 
-                       '-c' => :cost_factor }.freeze
-
     # Initializes the wrapped <tt>mecab</tt> instance with the
     # given <tt>options</tt>.
     # 
@@ -108,7 +89,7 @@ module Natto
     #                    type="0", \
     #                    filename="/usr/local/lib/mecab/dic/ipadic/sys.dic" \
     #                    charset="utf8">], \
-    #          @version="0.993">
+    #          @version="0.994">
     # 
     #     puts nm.parse('才能とは求める人間に与えられるものではない。')
     #     才能    サイノウ
@@ -128,10 +109,8 @@ module Natto
     #
     # @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 = self.class.parse_mecab_options(options) 
-          
       @dicts = []
 
       opt_str = self.class.build_options_str(@options)
@@ -146,7 +125,6 @@ module Natto
       # for both parsing as string and yielding a node object
       # N-Best parsing implementations
       if @options[:nbest] && @options[:nbest] > 1
-        # nbest parsing require lattice level >= 1
         self.mecab_set_lattice_level(@tagger, (@options[:lattice_level] || 1))
         @parse_tostr = lambda do |str| 
           return self.mecab_nbest_sparse_tostr(@tagger, @options[:nbest], str) || 
@@ -159,18 +137,19 @@ module Natto
             n = self.mecab_nbest_next_tonode(@tagger)
             raise(MeCabError.new(self.mecab_strerror(@tagger))) if n.nil? || n.address==0x0
             nlen = @options[:nbest]
-            nlen.times do
+            nlen.times do |i|
               s = str.bytes.to_a
               while n && n.address != 0x0
                 mn = Natto::MeCabNode.new(n)
-                if mn.is_nor?
-                  slen, sarr = mn.length, []
-                  slen.times { sarr << s.shift }
+                s = s.drop_while {|e| (e==0xa || e==0x20)}
+                if !s.empty?
+                  sarr = []
+                  mn.length.times { sarr << s.shift }
                   surf = sarr.pack('C*')
                   mn.surface = self.class.force_enc(surf)
-                  if @options[:output_format_type] || @options[:node_format]
-                    mn.feature = self.class.force_enc(self.mecab_format_node(@tagger, n)) 
-                  end
+                end
+                if @options[:output_format_type] || @options[:node_format]
+                  mn.feature = self.class.force_enc(self.mecab_format_node(@tagger, n)) 
                 end
                 nodes << mn if !mn.is_bos?
                 n = mn.next
@@ -191,13 +170,14 @@ module Natto
           n = self.mecab_sparse_tonode(@tagger, str) 
           raise(MeCabError.new(self.mecab_strerror(@tagger))) if n.nil? || n.address==0x0
           mn = Natto::MeCabNode.new(n)
-          n = mn.next if mn.next.address!=0x0 && mn.is_bos?
+          n = mn.next if mn.next.address!=0x0
           s = str.bytes.to_a
           while n && n.address!=0x0
             mn = Natto::MeCabNode.new(n)
-            if mn.is_nor?
-              slen, sarr = mn.length, []
-              slen.times { sarr << s.shift }
+            s = s.drop_while {|e| (e==0xa || e==0x20)}
+            if !s.empty?
+              sarr = []
+              mn.length.times { sarr << s.shift }
               surf = sarr.pack('C*')
               mn.surface = self.class.force_enc(surf)
             end
@@ -224,8 +204,10 @@ module Natto
     # @param [String] str
     # @return parsing result from <tt>mecab</tt>
     # @raise [MeCabError] if the <tt>mecab</tt> tagger cannot parse the given string <tt>str</tt>
+    # @raise [ArgumentError] if the given string <tt>str</tt> argument is <tt>nil</tt>
     # @see MeCabNode
     def parse(str)
+      raise ArgumentError.new 'String to parse cannot be nil' if str.nil?
       if block_given?
         nodes = @parse_tonodes.call(str)
         nodes.each {|n| yield n }
@@ -239,8 +221,10 @@ module Natto
     # @param [String] str
     # @return [Array] of parsed <tt>mecab</tt> nodes.
     # @raise [MeCabError] if the <tt>mecab</tt> tagger cannot parse the given string <tt>str</tt>
+    # @raise [ArgumentError] if the given string <tt>str</tt> argument is <tt>nil</tt>
     # @see MeCabNode
-    def readnodes(str)
+    def parse_as_nodes(str)
+      raise ArgumentError.new 'String to parse cannot be nil' if str.nil?
       @parse_tonodes.call(str)
     end
 
@@ -249,10 +233,24 @@ module Natto
     # @param [String] str
     # @return [Array] of parsed <tt>mecab</tt> result strings.
     # @raise [MeCabError] if the <tt>mecab</tt> tagger cannot parse the given string <tt>str</tt>
-    def readlines(str)
+    # @raise [ArgumentError] if the given string <tt>str</tt> argument is <tt>nil</tt>
+    def parse_as_strings(str)
+      raise ArgumentError.new 'String to parse cannot be nil' if str.nil?
       self.class.force_enc(@parse_tostr.call(str)).lines.to_a
     end
 
+    # DEPRECATED: use parse_as_nodes instead.
+    def readnodes(str)
+      $stdout.puts 'DEPRECATED: use parse_as_nodes instead'
+      parse_as_nodes(str)
+    end
+
+    # DEPRECATED: use parse_as_strings instead.
+    def readlines(str)
+      $stdout.puts 'DEPRECATED: use parse_as_strings instead'
+      parse_as_strings(str)
+    end
+
     # Returns human-readable details for the wrapped <tt>mecab</tt> tagger.
     # Overrides <tt>Object#to_s</tt>.
     #
@@ -288,77 +286,6 @@ module Natto
         self.mecab_destroy(ptr)
       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
-        opts = OptionParser.new do |opts|
-          opts.on('-r', '--rcfile ARG')  { |arg| h[:rcfile]   = arg.strip }
-          opts.on('-d', '--dicdir ARG')  { |arg| h[:dicdir]   = arg.strip }
-          opts.on('-u', '--userdic ARG') { |arg| h[:userdic]  = arg.strip }
-          opts.on('-l', '--lattice-level ARG') { |arg| h[:lattice_level]  = arg.strip.to_i } # !deprecated in 0.99!!!
-          opts.on('-O', '--output-format-type ARG') { |arg| h[:output_format_type]  = arg.strip }
-          opts.on('-a', '--all-morphs')  { |arg| h[:all_morphs]  = true }
-          opts.on('-N', '--nbest ARG')   { |arg| h[:nbest]    = arg.strip.to_i }
-          #opts.on('-m', '--marginal')  { |arg| h[:marginal]  = true }
-          opts.on('-F', '--node-format ARG') { |arg| h[:node_format]  = arg.strip }
-          opts.on('-U', '--unk-format ARG') { |arg| h[:unk_format]  = arg.strip }
-          opts.on('-B', '--bos-format ARG') { |arg| h[:bos_format]  = arg.strip }
-          opts.on('-E', '--eos-format ARG') { |arg| h[:eos_format]  = arg.strip }
-          opts.on('-S', '--eon-format ARG') { |arg| h[:eon_format]  = arg.strip }
-          opts.on('-x', '--unk-feature ARG') { |arg| h[:unk_feature]  = arg.strip }
-          opts.on('-b', '--input-buffer-size ARG')   { |arg| h[:input_buffer_size]  = arg.strip.to_i }
-          #opts.on('-M', '--open-mutable-dictionary')  { |arg| h[:open_mutable_dictionary]  = true }
-          opts.on('-C', '--allocate-sentence')  { |arg| h[:allocate_sentence]  = true }
-          opts.on('-t', '--theta ARG')   { |arg| h[:theta] = arg.strip.to_f }
-          opts.on('-c', '--cost-factor ARG')   { |arg| h[:cost_factor] = arg.strip.to_i }
-        end
-        opts.parse!(options.split)
-      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
-      raise MeCabError.new("Invalid N value") if h[:nbest] && (h[:nbest] < 1 || h[:nbest] > 512)
-      h
-    end
-
-    # Returns a string-representation of the options to
-    # be passed in the construction of the <tt>mecab</tt> tagger.
-    #
-    # @param [Hash] options 
-    # @return [String] representation of the options to the <tt>mecab</tt> tagger
-    def self.build_options_str(options={})
-      opt = []
-      SUPPORTED_OPTS.values.each do |k|
-        if options.has_key? k
-          key = k.to_s.gsub('_', '-')  
-          if %w( all-morphs allocate-sentence ).include? key
-            opt << "--#{key}" if options[k]==true
-          else
-            opt << "--#{key}=#{options[k]}"
-          end
-        end
-      end
-      opt.empty? ? "" : opt.join(" ") 
-    end
   end
 
   # <tt>MeCabError</tt> is a general error class 
@@ -429,14 +356,13 @@ module Natto
             :version,  :ushort,
             :next,     :pointer
    
-    if RUBY_VERSION.to_f < 1.9
+    if Object.respond_to?(:type) && Object.respond_to?(:class)
       alias_method :deprecated_type, :type
-      # <tt>Object#type</tt> override defined when <tt>RUBY_VERSION</tt> is
-      # older than 1.9. This is a hack to avoid the <tt>Object#type</tt>
-      # deprecation warning thrown up in Ruby 1.8.7.
+      # <tt>Object#type</tt> override defined when both <tt>type</tt> and
+      # <tt>class</tt> are Object methods. This is a hack to avoid the 
+      # <tt>Object#type</tt> deprecation warning thrown up in Ruby 1.8.7
+      # and in JRuby.
       #
-      # <i>This method override is not defined when the Ruby interpreter
-      # is 1.9 or greater.</i>
       # @return [Fixnum] <tt>mecab</tt> dictionary type
       def type
         self[:type]

data/lib/natto/option_parse.rb

@@ -0,0 +1,109 @@
+module Natto
+
+  # Module <tt>OptionParse</tt> encapsulates methods and behavior 
+  # for parsing the various <tt>mecab</tt> options supported by
+  # <tt>Natto</tt>.
+  module OptionParse
+    require 'optparse'
+
+    # Mapping of mecab short-style configuration options to the <tt>mecab</tt> tagger.
+    # See the <tt>mecab</tt> help for more details. 
+    SUPPORTED_OPTS = { '-r' => :rcfile, 
+                       '-d' => :dicdir, 
+                       '-u' => :userdic, 
+                       '-l' => :lattice_level, 
+                       '-O' => :output_format_type, 
+                       '-a' => :all_morphs,
+                       '-N' => :nbest, 
+                       '-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, 
+                       '-t' => :theta, 
+                       '-c' => :cost_factor }.freeze
+    
+    # @private
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # @private
+    module ClassMethods
+    
+      # 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 parse_mecab_options(options={})
+        h = {}
+        if options.is_a? String
+          opts = OptionParser.new do |opts|
+            opts.on('-r', '--rcfile ARG')  { |arg| h[:rcfile]   = arg.strip }
+            opts.on('-d', '--dicdir ARG')  { |arg| h[:dicdir]   = arg.strip }
+            opts.on('-u', '--userdic ARG') { |arg| h[:userdic]  = arg.strip }
+            opts.on('-l', '--lattice-level ARG') { |arg| h[:lattice_level]  = arg.strip.to_i } # !deprecated in 0.99!!!
+            opts.on('-O', '--output-format-type ARG') { |arg| h[:output_format_type]  = arg.strip }
+            opts.on('-a', '--all-morphs')  { |arg| h[:all_morphs]  = true }
+            opts.on('-N', '--nbest ARG')   { |arg| h[:nbest]    = arg.strip.to_i }
+            #opts.on('-m', '--marginal')  { |arg| h[:marginal]  = true }
+            opts.on('-F', '--node-format ARG') { |arg| h[:node_format]  = arg.strip }
+            opts.on('-U', '--unk-format ARG') { |arg| h[:unk_format]  = arg.strip }
+            opts.on('-B', '--bos-format ARG') { |arg| h[:bos_format]  = arg.strip }
+            opts.on('-E', '--eos-format ARG') { |arg| h[:eos_format]  = arg.strip }
+            opts.on('-S', '--eon-format ARG') { |arg| h[:eon_format]  = arg.strip }
+            opts.on('-x', '--unk-feature ARG') { |arg| h[:unk_feature]  = arg.strip }
+            opts.on('-b', '--input-buffer-size ARG')   { |arg| h[:input_buffer_size]  = arg.strip.to_i }
+            #opts.on('-M', '--open-mutable-dictionary')  { |arg| h[:open_mutable_dictionary]  = true }
+            opts.on('-C', '--allocate-sentence')  { |arg| h[:allocate_sentence]  = true }
+            opts.on('-t', '--theta ARG')   { |arg| h[:theta] = arg.strip.to_f }
+            opts.on('-c', '--cost-factor ARG')   { |arg| h[:cost_factor] = arg.strip.to_i }
+          end
+          opts.parse!(options.split)
+        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
+        raise MeCabError.new("Invalid N value") if h[:nbest] && (h[:nbest] < 1 || h[:nbest] > 512)
+        h
+      end
+
+      # Returns a string-representation of the options to
+      # be passed in the construction of the <tt>mecab</tt> tagger.
+      #
+      # @param [Hash] options 
+      # @return [String] representation of the options to the <tt>mecab</tt> tagger
+      def build_options_str(options={})
+        opt = []
+        SUPPORTED_OPTS.values.each do |k|
+          if options.has_key? k
+            key = k.to_s.gsub('_', '-')  
+            if %w( all-morphs allocate-sentence ).include? key
+              opt << "--#{key}" if options[k]==true
+            else
+              opt << "--#{key}=#{options[k]}"
+            end
+          end
+        end
+        opt.empty? ? "" : opt.join(" ") 
+      end
+    end
+  end
+end

data/lib/natto/version.rb

@@ -21,7 +21,11 @@
 #
 # Module <tt>Natto::Binding</tt> encapsulates methods and behavior 
 # which are made available via <tt>FFI</tt> bindings to <tt>mecab</tt>.
+#
+# Module <tt>OptionParse</tt> encapsulates methods and behavior 
+# for parsing the various <tt>mecab</tt> options supported by
+# <tt>Natto</tt>.
 module Natto
   # Version string for this Rubygem.
-  VERSION = "0.9.4"
+  VERSION = "0.9.5"
 end

metadata

@@ -1,34 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: natto
 version: !ruby/object:Gem::Version
-  version: 0.9.4
-  prerelease: 
+  prerelease:
+  version: 0.9.5
 platform: ruby
 authors:
 - Brooke M. Fujita
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-02-26 00:00:00.000000000 Z
+date: 2012-09-16 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &341055920 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: &2056 !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.6.3
-  type: :runtime
+    none: false
+  requirement: *2056
   prerelease: false
-  version_requirements: *341055920
+  type: :runtime
 description: ! 'natto is a gem bridging Ruby and MeCab using FFI (foreign function
   interface). No compilation is necessary, and natto will run on CRuby (mri/yarv)
   and JRuby (jvm) equally well, on any OS.
 
-  ruby で mecab を自由に利用できる natto をぜひ試してください。
+  ruby ? mecab ????????? natto ???????????
 
-'
+  '
 email: buruzaemon@gmail.com
 executables: []
 extensions: []
@@ -36,8 +36,9 @@ extra_rdoc_files: []
 files:
 - lib/natto.rb
 - lib/natto/binding.rb
-- lib/natto/version.rb
+- lib/natto/option_parse.rb
 - lib/natto/utils.rb
+- lib/natto/version.rb
 - README.md
 - LICENSE
 - CHANGELOG
@@ -45,30 +46,29 @@ files:
 homepage: https://bitbucket.org/buruzaemon/natto/overview
 licenses:
 - BSD
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+  none: false
 requirements:
-- MeCab, 0.993 or greater
+- MeCab, 0.994 or greater
 - FFI, 0.6.3 or greater
-rubyforge_project: 
-rubygems_version: 1.8.17
-signing_key: 
+rubyforge_project:
+rubygems_version: 1.8.15
+signing_key:
 specification_version: 3
-summary: natto combines the Ruby programming language with MeCab, the part-of-speech
-  and morphological analyzer for the Japanese language.
+summary: natto combines the Ruby programming language with MeCab, the part-of-speech and morphological analyzer for the Japanese language.
 test_files: []
-has_rdoc: 
+...