natto 0.9.8 → 0.9.9

data/CHANGELOG

@@ -1,5 +1,11 @@
 ## CHANGELOG
 
+- __2015/03/31__: 0.9.9 release.
+    - Issue 21/34: Implemented boundary constraint parsing.
+    - Issue 26: Removing deprecated methods parse_as_nodes, parse_as_strings, readnodes and readlines.
+    - Issue 32: Fixed partial parsing.
+    - Updated documentation for new MeCab home at http://taku910.github.io/mecab/.
+
 - __2015/02/10__: 0.9.8 release.
     - Migrated natto code home from Bitbucket to GitHub.
     - Improved documentation following said migration.
@@ -7,16 +13,10 @@
     - Updating LICENSE for year 2015. 
 
 - __2014/12/20__: 0.9.7 release.
-    - Issue 14: [adding automatic discovery for mecab library; no need to
-	explicitly set
-	MECAB_PATH!](https://bitbucket.org/buruzaemon/natto/issue/14/automatic-discovery-of-libmecab-path-and)
-    - Issue 15: [refactored node-parsing to use Enumerator instead of
-	materializing every node and stuffing into
-	array](https://bitbucket.org/buruzaemon/natto/issue/15/use-enumerator-when-parsing-mecab-nodes)
-    - Issue 17: [adding filepath to MeCab and
-	DictionaryInfo](https://bitbucket.org/buruzaemon/natto/issue/17/use-filerealpath-value-for-all-file-paths)
-    - Issue 18: [bug-fix for node-formatting during default node
-	parse](https://bitbucket.org/buruzaemon/natto/issue/18/no-node-formatting-when-using-default-node)
+    - Issue 14: adding automatic discovery for mecab library; no need to explicitly set MECAB_PATH
+    - Issue 15: refactored node-parsing to use Enumerator instead of materializing every node and stuffing into array
+    - Issue 17: adding filepath to MeCab and DictionaryInfo
+    - Issue 18: bug-fix for node-formatting during default node parse
     - Deprecating parse_as_nodes and parse_as_strings; please use parse instead!
     - CAUTION: parse_as_nodes, parse_as_strings, readnodes and readlines will be removed in the following release!
     - Enhancements to to_s methods for both MeCab and DictionaryInfo
@@ -36,8 +36,8 @@
     - Removing automatic library load for Cygwin platform (does not compile) 
 
 - __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) 
+    - Fixed Issue 9: trimされていない文字列のparse
+    - Fixed 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)

data/README.md

@@ -1,16 +1,16 @@
-# natto
+# natto [![Gem Version](https://badge.fury.io/rb/natto.svg)](http://badge.fury.io/rb/natto) [![Build Status](https://travis-ci.org/buruzaemon/natto.svg?branch=master)](https://travis-ci.org/buruzaemon/natto) 
 A Tasty Ruby Binding with MeCab
 
 ## What is natto?
 A gem leveraging FFI (foreign function interface), natto combines the
 [Ruby programming language](http://www.ruby-lang.org/) with 
-[MeCab](http://mecab.googlecode.com/svn/trunk/mecab/doc/index.html), the part-of-speech
+[MeCab](http://taku910.github.io/mecab/), the part-of-speech
 and morphological analyzer for the Japanese language.
 
--  No compiler is necessary, as natto is _not_ a C extension.
--  It will run on CRuby (mri/yarv) and JRuby (jvm) equally well.
--  It will work with MeCab installations on Windows, Unix/Linux or OS X.
 -  natto provides a naturally Ruby-esque interface to MeCab.
+-  It runs on both CRuby (mri/yarv) and JRuby (jvm).
+-  It works with MeCab installations on Windows, Unix/Linux and OS X.
+-  No compiler is necessary, as natto is _not_ a C extension.
 
 You can learn more about [natto at GitHub](https://github.com/buruzaemon/natto).
 
@@ -18,8 +18,8 @@ You can learn more about [natto at GitHub](https://github.com/buruzaemon/natto).
 ## Requirements
 natto requires the following:
 
--  [MeCab _0.996_](http://code.google.com/p/mecab/downloads/list)
--  A system dictionary, like [mecab-ipadic](https://mecab.googlecode.com/files/mecab-ipadic-2.7.0-20070801.tar.gz) or [mecab-jumandic](https://mecab.googlecode.com/files/mecab-jumandic-5.1-20070304.tar.gz)
+-  [MeCab _0.996_](http://taku910.github.io/mecab/#download)
+-  A system dictionary, like mecab-ipadic (recommended), mecab-jumandic or unidic, all available on the [MeCab downloads page](http://taku910.github.io/mecab/#download)
 -  `libmecab-devel` if you are on Linux, since natto uses `mecab-config`
 -  Ruby _1.9 or greater_
 -  [ffi _1.9.0 or greater_](http://rubygems.org/gems/ffi)
@@ -29,7 +29,7 @@ Install natto with the following gem command:
 
     gem install natto
 
-This will automatically install the [ffi](http://rubygems.org/gems/ffi) rubygem, which natto uses to bind to the `mecab` library.
+This will automatically install the [ffi](http://rubygems.org/gems/ffi) rubygem, which natto uses to bind to the MeCab 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), a MSYS/MinGW based toolkit that enables your Windows Ruby installation to build many of the native C/C++ extensions available, including ffi.
@@ -45,40 +45,38 @@ However, if you are using a CRuby on Windows, then you will first need to instal
 6. If you are on a 64-bit Windows and you use a 64-bit Ruby or JRuby, then you might want to [build a 64-bit version of libmecab.dll](https://github.com/buruzaemon/natto/wiki/64-Bit-Windows).
 
 
-## Configuration
--  ***No explicit configuration should be necessary, as natto will try to locate the `mecab` library based upon its runtime environment.***
-    - On Windows, it will query the Windows Registry to determine where `libmecab.dll` is installed
-    - On OS X and \*nix, it will query `mecab-config --libs` 
--   ***But if natto cannot find the `mecab` library, `LoadError` will be raised.***
-    - Please set the `MECAB_PATH` environment variable to the exact name/path to your `mecab` library.
-    - e.g., for OS X
+## Automatic Configuration
+No explicit configuration should be necessary, as natto will try to locate the MeCab library based upon its runtime environment.
+- On OS X and \*nix, it will query `mecab-config --libs` 
+- On Windows, it will query the Windows Registry to determine where `libmecab.dll` is installed
+
+## Explicit configuration via `MECAB_PATH` and `MECAB_CHARSET`
+If natto cannot find the MeCab library, `LoadError` will be raised. Please set the `MECAB_PATH` environment variable to the exact name/path to your MeCab library.
 
-            export MECAB_PATH=/usr/local/Cellar/mecab/0.996/lib/libmecab.dylib 
+- e.g., for OS X
 
-    - e.g., for bash on UNIX/Linux
+        export MECAB_PATH=/usr/local/Cellar/mecab/0.996/lib/libmecab.dylib 
 
-            export MECAB_PATH=/usr/local/lib/libmecab.so
+- e.g., for bash on UNIX/Linux
 
-    - e.g., on Windows
+        export MECAB_PATH=/usr/local/lib/libmecab.so
 
-            set MECAB_PATH=C:\Program Files\MeCab\bin\libmecab.dll
+- e.g., on Windows
 
-    - e.g., from within a Ruby program
+        set MECAB_PATH=C:\Program Files\MeCab\bin\libmecab.dll
 
-            ENV['MECAB_PATH']='/usr/local/lib/libmecab.so'
+- e.g., from within a Ruby program
+
+        ENV['MECAB_PATH']='/usr/local/lib/libmecab.so'
 
 ## Usage
 
+Here's a very quick guide to using natto.
+
+Instantiate a reference to the MeCab library, and display some details:
 
-    # Quick Start
-    # -----------
-    #  
-    # No explicit configuration should be necessary!
-    #
     require 'natto'
 
-    # first, create an instance of Natto::MeCab
-    #
     nm = Natto::MeCab.new
     => #<Natto::MeCab:0x28d30748 
          @tagger=#<FFI::Pointer address=0x28a97d50>, \
@@ -90,32 +88,27 @@ However, if you are using a CRuby on Windows, then you will first need to instal
                  type=0>] \
          @version=0.996>
     
-    # display MeCab version
-    #
     puts nm.version
     => 0.996 
 
-    # display full pathname to MeCab library
-    #
+----
+
+Display details about the system dictionary used by MeCab:
+
     puts nm.libpath
     => /usr/local/lib/libmecab.so 
 
-    # reference to MeCab system dictionary
-    #
     sysdic = nm.dicts.first
-
-    # display full pathname to system dictionary file
-    #
     puts sysdic.filepath
     => /usr/local/lib/mecab/dic/ipadic/sys.dic
 
-    # what charset (encoding) is the system dictionary?
-    #
     puts sysdic.charset
     => utf8 
-  
-    # parse text and send output to stdout
-    #
+ 
+----
+
+Parse Japanese text and send the MeCab result as a single string to stdout:
+
     puts nm.parse('俺の名前は星野豊だ！！そこんとこヨロシク！')
     俺      名詞,代名詞,一般,*,*,*,俺,オレ,オレ
     の      助詞,連体化,*,*,*,*,の,ノ,ノ
@@ -133,12 +126,22 @@ However, if you are using a CRuby on Windows, then you will first need to instal
     ！      記号,一般,*,*,*,*,！,！,！
     EOS
 
-    # parse more text and use a block to:
-    # - iterate over the resulting MeCabNode instances
-    # - output morpheme surface and part-of-speech ID
-    #
-    # * ignore any end-of-sentence nodes
-    #
+----
+
+If a block is passed to `parse`, you can iterate over the list of resulting `MeCabNode`
+instances to access more detailed information about each morpheme. 
+
+In this example, the following attributes and methods for `MeCabNode` are used:
+
+- `surface` - the morpheme surface
+- `posid` - node part-of-speech ID (dictionary-dependent)
+- `is_eos?` - is this `MeCabNode` an end-of-sentence node?
+
+This iterates over the morpheme nodes in the given text,
+and outputs a formatted, tab-delimited line with the
+morpheme surface and part-of-speech ID, ignoring any end-of-sentence
+nodes:
+
     nm.parse('世界チャンプ目指してんだなこれがっ!!夢なの、俺のっ!!') do |n|
       puts "#{n.surface}\tpart-of-speech id: #{n.posid}" if !n.is_eos?
     end
@@ -160,37 +163,46 @@ However, if you are using a CRuby on Windows, then you will first need to instal
     のっ    part-of-speech id: 31
     !!      part-of-speech id: 36
 
-    # for more complex parsing, such as that for natural 
-    # language processing tasks, it is far more efficient
-    # to iterate over MeCab nodes using an Enumerator
-    # 
-    # this example uses the -F node-format option to customize
-    # the resulting MeCabNode feature attribute to extract:
-    # - %m    ... surface
-    # - %f[0] ... part-of-speech
-    # - %f[7] ... reading
-    #
-    nm = Natto::MeCab.new('-F%m\t%f[0]\t%f[7]')
+----
+
+For more complex parsing, such as that for natural language
+processing tasks, it is far more efficient to use `enum_parse` to
+obtain an [`Enumerator`](http://ruby-doc.org/core-2.2.0/Enumerator.html)
+to iterate over the resulting `MeCabNode` instances. An `Enumerator`
+yields each `MeCabNode` instance without first materializing all
+instances at once, thus being more efficient.
+
+This example uses the `-F` node-format option to customize
+the resulting `MeCabNode` feature attribute to extract:
+
+- `%m` - morpheme surface
+- `%f[0]` - node part-of-speech
+- `%f[7]` - reading
+
+Note that we can move the `Enumerator` both forwards and backwards, rewind it
+back to the beginning, and then iterate over it.
 
+    nm = Natto::MeCab.new('-F%m\t%f[0]\t%f[7]')
+    
     enum = nm.enum_parse('この星の一等賞になりたいの卓球で俺は、そんだけ！')
     => #<Enumerator: #<Enumerator::Generator:0x00000002ff3898>:each>
-
+    
     enum.next
     => #<Natto::MeCabNode:0x000000032eed68 \
          @pointer=#<FFI::Pointer address=0x000000005ffb48>, \
          stat=0, \
          @surface="この", \
          @feature="この   連体詞  コノ">
-
+    
     enum.peek
     => #<Natto::MeCabNode:0x00000002fe2110a \
          @pointer=#<FFI::Pointer address=0x000000005ffdb8>, \
          stat=0, \
          @surface="星", \
          @feature="星       名詞    ホシ"> 
-    
+        
     enum.rewind
-
+    
     # again, ignore any end-of-sentence nodes
     enum.each { |n| puts n.feature if !n.is_eos? }
     この    連体詞  コノ
@@ -211,7 +223,52 @@ However, if you are using a CRuby on Windows, then you will first need to instal
     だけ    助詞    ダケ
     ！      記号    ！
 
-   
+----
+
+[Partial parsing](http://taku910.github.io/mecab/partial.html) allows you to
+pass hints to MeCab on how to tokenize morphemes when parsing. With boundary
+constraint parsing, you can specify either
+a [Regexp](http://ruby-doc.org/core-2.2.1/Regexp.html) or
+[String](http://ruby-doc.org/core-2.2.1/String.html) to tell MeCab where the
+boundaries of a morpheme should be. Use the new `boundary_constraints` keyword.
+For hints on tokenization, please see
+[String#scan](http://ruby-doc.org/core-2.2.1/String.html#method-i-scan)
+
+This example uses the `-F` node-format option to customize
+the resulting `MeCabNode` feature attribute to extract:
+
+- `%m` - morpheme surface
+- `%f[0]` - node part-of-speech
+- `%s` - node `stat` status value, 1 is `unknown`
+
+Note that any such morphemes captured will have node `stat` status of unknown.
+
+    nm = Natto::MeCab.new('-F%m,\s%f[0],\s%s')
+
+    text = '心の中で3回唱え、 ヒーロー見参！ヒーロー見参！ヒーロー見参！'
+    pattern = /ヒーロー見参/
+
+    nm.enum_parse(text, boundary_constraints: pattern).each do |n|
+      puts n.feature if !(n.is_bos? || n.is_eos?)
+    end
+
+    # desired morpheme boundary specified with Regexp /ヒーロー見参/
+    心, 名詞, 0
+    の, 助詞, 0
+    中, 名詞, 0
+    で, 助詞, 0
+    3, 名詞, 1
+    回, 名詞, 0
+    唱え, 動詞, 0
+    、, 記号, 0
+    ヒーロー見参, 名詞, 1
+    ！, 記号, 0
+    ヒーロー見参, 名詞, 1
+    ！, 記号, 0
+    ヒーロー見参, 名詞, 1
+    ！, 記号, 0
+
+
 
 ## Learn more 
 - You can read more about natto on the [project Wiki](https://github.com/buruzaemon/natto/wiki).

data/lib/natto/binding.rb

@@ -66,12 +66,7 @@ module Natto
 
     ffi_lib find_library
 
-    # new interface
-    attach_function :mecab_model_new2, [:string], :pointer
-    attach_function :mecab_model_destroy, [:pointer], :void
-    attach_function :mecab_model_dictionary_info, [:pointer], :pointer
-
-    # old interface
+    # C interface
     attach_function :mecab_new2, [:string], :pointer
     attach_function :mecab_version, [], :string
     attach_function :mecab_strerror, [:pointer],:string
@@ -88,6 +83,26 @@ module Natto
     attach_function :mecab_format_node, [:pointer, :pointer], :string
     attach_function :mecab_dictionary_info, [:pointer], :pointer
 
+    attach_function :mecab_lattice_new, [], :pointer
+    attach_function :mecab_lattice_destroy, [:pointer], :void
+    attach_function :mecab_lattice_clear, [:pointer], :void
+    attach_function :mecab_lattice_is_available, [:pointer], :int
+    attach_function :mecab_lattice_get_bos_node, [:pointer], :pointer
+    attach_function :mecab_lattice_set_sentence, [:pointer, :string], :void
+    attach_function :mecab_lattice_get_size, [:pointer], :int
+    attach_function :mecab_lattice_set_z, [:pointer, :float], :void
+    attach_function :mecab_lattice_set_theta, [:pointer, :float], :void
+    attach_function :mecab_lattice_next, [:pointer], :int
+    attach_function :mecab_lattice_get_request_type, [:pointer], :int
+    attach_function :mecab_lattice_add_request_type, [:pointer, :int], :void
+    attach_function :mecab_lattice_set_request_type, [:pointer, :int], :void
+    attach_function :mecab_lattice_tostr, [:pointer], :string
+    attach_function :mecab_lattice_nbest_tostr, [:pointer, :int], :string
+    attach_function :mecab_lattice_get_boundary_constraint, [:pointer, :int], :int
+    attach_function :mecab_lattice_set_boundary_constraint, [:pointer, :int, :int], :void
+    attach_function :mecab_parse_lattice, [:pointer, :pointer], :int
+    attach_function :mecab_lattice_strerror, [:pointer], :string
+
     # @private
     module ClassMethods
 
@@ -95,18 +110,6 @@ module Natto
         Natto::Binding.find_library
       end
 
-      def mecab_model_new2(options_str)
-        Natto::Binding.mecab_model_new2(options_str)
-      end
-      
-      def mecab_model_destroy(m_ptr)
-        Natto::Binding.mecab_model_destroy(m_ptr)
-      end
-
-      def mecab_model_dictionary_info(m_ptr)
-        Natto::Binding.mecab_model_dictionary_info(m_ptr)
-      end
-      
       # ----------------------------------------
       def mecab_new2(options_str)
         Natto::Binding.mecab_new2(options_str)
@@ -116,60 +119,136 @@ module Natto
         Natto::Binding.mecab_version
       end
 
-      def mecab_strerror(m_ptr)
-        Natto::Binding.mecab_strerror(m_ptr)
+      def mecab_strerror(tptr)
+        Natto::Binding.mecab_strerror(tptr)
       end
 
-      def mecab_destroy(m_ptr)
-        Natto::Binding.mecab_destroy(m_ptr)
+      def mecab_destroy(tptr)
+        Natto::Binding.mecab_destroy(tptr)
       end
 
-      def mecab_set_partial(m_ptr, ll)
-        Natto::Binding.mecab_set_partial(m_ptr, ll)
+      def mecab_set_partial(tptr, ll)
+        Natto::Binding.mecab_set_partial(tptr, ll)
       end
       
-      def mecab_set_theta(m_ptr, t)
-        Natto::Binding.mecab_set_theta(m_ptr, t)
+      def mecab_set_theta(tptr, t)
+        Natto::Binding.mecab_set_theta(tptr, t)
       end
 
-      def mecab_set_lattice_level(m_ptr, ll)
-        Natto::Binding.mecab_set_lattice_level(m_ptr, ll)
+      def mecab_set_lattice_level(tptr, ll)
+        Natto::Binding.mecab_set_lattice_level(tptr, ll)
       end
       
-      def mecab_set_all_morphs(m_ptr, am)
-        Natto::Binding.mecab_set_all_morphs(m_ptr, am)
+      def mecab_set_all_morphs(tptr, am)
+        Natto::Binding.mecab_set_all_morphs(tptr, am)
       end
 
-      def mecab_sparse_tostr(m_ptr, str)
-        Natto::Binding.mecab_sparse_tostr(m_ptr, str)
+      def mecab_sparse_tostr(tptr, str)
+        Natto::Binding.mecab_sparse_tostr(tptr, str)
       end
       
-      def mecab_sparse_tonode(m_ptr, str)
-        Natto::Binding.mecab_sparse_tonode(m_ptr, str)
+      def mecab_sparse_tonode(tptr, str)
+        Natto::Binding.mecab_sparse_tonode(tptr, str)
       end
 
-      def mecab_nbest_next_tonode(m_ptr)
-        Natto::Binding.mecab_nbest_next_tonode(m_ptr)
+      def mecab_nbest_next_tonode(tptr)
+        Natto::Binding.mecab_nbest_next_tonode(tptr)
       end
 
-      def mecab_nbest_init(m_ptr, str)
-        Natto::Binding.mecab_nbest_init(m_ptr, str)
+      def mecab_nbest_init(tptr, str)
+        Natto::Binding.mecab_nbest_init(tptr, str)
       end
 
-      def mecab_nbest_sparse_tostr(m_ptr, n, str)
-        Natto::Binding.mecab_nbest_sparse_tostr(m_ptr, n, str)
+      def mecab_nbest_sparse_tostr(tptr, n, str)
+        Natto::Binding.mecab_nbest_sparse_tostr(tptr, n, str)
       end
 
-      def mecab_nbest_next_tonode(m_ptr)
-        Natto::Binding.mecab_nbest_next_tonode(m_ptr)
+      def mecab_nbest_next_tonode(tptr)
+        Natto::Binding.mecab_nbest_next_tonode(tptr)
       end
 
-      def mecab_format_node(m_ptr, n_ptr)
-        Natto::Binding.mecab_format_node(m_ptr, n_ptr)
+      def mecab_format_node(tptr, nptr)
+        Natto::Binding.mecab_format_node(tptr, nptr)
+      end
+      
+      def mecab_dictionary_info(tptr)
+        Natto::Binding.mecab_dictionary_info(tptr)
       end
       
-      def mecab_dictionary_info(m_ptr)
-        Natto::Binding.mecab_dictionary_info(m_ptr)
+      def mecab_lattice_new()
+        Natto::Binding.mecab_lattice_new()
+      end
+
+      def mecab_lattice_destroy(lptr)
+        Natto::Binding.mecab_lattice_destroy(lptr)
+      end
+    
+      def mecab_lattice_clear(lptr)
+        Natto::Binding.mecab_lattice_clear(lptr)
+      end
+    
+      def mecab_lattice_is_available(lptr)
+        Natto::Binding.mecab_lattice_is_available(lptr)
+      end
+
+      def mecab_lattice_get_bos_node(lptr)
+        Natto::Binding.mecab_lattice_get_bos_node(lptr)
+      end
+    
+      def mecab_lattice_set_sentence(lptr, str)
+        Natto::Binding.mecab_lattice_set_sentence(lptr, str)
+      end
+
+      def mecab_lattice_get_size(lptr)
+        Natto::Binding.mecab_lattice_get_size(lptr)
+      end
+    
+      def mecab_lattice_set_z(lptr, z)
+        Natto::Binding.mecab_lattice_set_z(lptr, z)
+      end
+
+      def mecab_lattice_set_theta(lptr, t)
+        Natto::Binding.mecab_lattice_set_theta(lptr, t)
+      end
+
+      def mecab_lattice_next(lptr)
+        Natto::Binding.mecab_lattice_next(lptr)
+      end
+ 
+      def mecab_lattice_get_request_type(lptr)
+        Natto::Binding.mecab_lattice_get_request_type(lptr)
+      end
+      
+      def mecab_lattice_add_request_type(lptr, rtype)
+        Natto::Binding.mecab_lattice_add_request_type(lptr, rtype)
+      end
+
+      def mecab_lattice_set_request_type(lptr, rtype)
+        Natto::Binding.mecab_lattice_set_request_type(lptr, rtype)
+      end
+
+      def mecab_lattice_tostr(lptr)
+        Natto::Binding.mecab_lattice_tostr(lptr)
+      end
+
+      def mecab_lattice_nbest_tostr(lptr, n)
+        Natto::Binding.mecab_lattice_nbest_tostr(lptr, n)
+      end
+
+      def mecab_lattice_get_boundary_constraint(lptr, pos)
+        Natto::Binding.mecab_lattice_get_boundary_constraint(lptr, pos)
+      end
+
+      def mecab_lattice_set_boundary_constraint(lptr, pos, btype)
+        Natto::Binding.mecab_lattice_set_boundary_constraint(lptr, pos, btype)
+      end
+
+      def mecab_parse_lattice(tptr, lptr)
+        Natto::Binding.mecab_parse_lattice(tptr, lptr)
+      end
+
+      def mecab_lattice_strerror(lptr)
+        Natto::Binding.mecab_lattice_strerror(lptr)
       end
     end
   end

data/lib/natto/natto.rb

@@ -4,8 +4,8 @@ require 'natto/option_parse'
 require 'natto/struct'
 
 module Natto 
-  # `MeCab` is a wrapper class for the `mecab` tagger.
-  # Options to the `mecab` tagger are passed in as a string
+  # `MeCab` is a wrapper class for the MeCab `Tagger`.
+  # Options to the MeCab `Tagger` are passed in as a string
   # (MeCab command-line style) or as a Ruby-style hash at
   # initialization.
   #
@@ -45,6 +45,7 @@ module Natto
   #     。      記号,句点,*,*,*,*,。,。,。
   #     EOS
   #
+  #
   #     # pass a block to iterate over each MeCabNode instance
   #     #
   #     nm.parse(text) do |n| 
@@ -101,10 +102,52 @@ module Natto
   #     13: 。,。,記号,7
   #
   #
+  #     # Boundary constraint parsing with output formatting.
+  #     # %m   ... morpheme surface
+  #     # %F,  ... comma-delimited ChaSen feature values
+  #     #          part-of-speech (index 0) 
+  #     # %2   ... MeCab node status value (1 unknown)
+  #     #
+  #     nm = Natto::MeCab.new('-F%m,\s%f[0],\s%s')
+  #
+  #     enum = nm.enum_parse(text, boundary_constraint: /見えねえ風景/)
+  #     => #<Enumerator: #<Enumerator::Generator:0x00000801d7aa38>:each>
+  #
+  #     # output the feature attribute of each MeCabNode
+  #     # ignoring any beginning- or end-of-sentence nodes
+  #     #
+  #     enum.each do |n|
+  #       puts n.feature if !(n.is_bos? or n.is_eos?)
+  #     end
+  #     凡人, 名詞, 0
+  #     に, 助詞, 0
+  #     しか, 助詞, 0
+  #     見えねえ風景, 名詞, 1
+  #     って, 助詞, 0
+  #     の, 名詞, 0
+  #     が, 助詞, 0
+  #     ある, 動詞, 0
+  #     ん, 名詞, 0
+  #     だ, 助動詞, 0
+  #     よ, 助詞, 0
+  #     。, 記号, 0
+  #
   class MeCab
     include Natto::Binding
     include Natto::OptionParse
  
+    MECAB_LATTICE_ONE_BEST = 1
+    MECAB_LATTICE_NBEST = 2
+    MECAB_LATTICE_PARTIAL = 4
+    MECAB_LATTICE_MARGINAL_PROB = 8
+    MECAB_LATTICE_ALTERNATIVE = 16
+    MECAB_LATTICE_ALL_MORPHS = 32
+    MECAB_LATTICE_ALLOCATE_SENTENCE = 64
+
+    MECAB_ANY_BOUNDARY = 0
+    MECAB_TOKEN_BOUNDARY = 1
+    MECAB_INSIDE_TOKEN = 2
+
     # @return [FFI:Pointer] pointer to MeCab tagger.
     attr_reader :tagger
     # @return [String] absolute filepath to MeCab library.
@@ -113,10 +156,10 @@ module Natto
     attr_reader :options
     # @return [Array] listing of all of dictionaries referenced.
     attr_reader :dicts
-    # @return [String] `MeCab` versions.
+    # @return [String] `MeCab` version.
     attr_reader :version
 
-    # Initializes the wrapped `mecab` instance with the
+    # Initializes the wrapped `Tagger` instance with the
     # given `options`.
     # 
     # Options supported are:
@@ -174,7 +217,7 @@ module Natto
     #     。      。
     #     EOS
     #
-    # @param [Hash, String] options MeCab options for tagger
+    # @param options [Hash, String] the MeCab options for tagger
     # @raise [MeCabError] if `mecab` cannot be initialized with the given `options`
     def initialize(options={})
       @options = self.class.parse_mecab_options(options) 
@@ -191,31 +234,159 @@ module Natto
       self.mecab_set_all_morphs(@tagger, 1) if @options[:all_morphs]
       self.mecab_set_partial(@tagger, 1) if @options[:partial]
        
-      # Set mecab parsing implementations for N-best and regular parsing,
-      # for both parsing as string and yielding a node object
-      if @options[:nbest] && @options[:nbest] > 1
-        # N-Best parsing implementations
-        self.mecab_set_lattice_level(@tagger, (@options[:lattice_level] || 1))
-
-        @parse_tostr = lambda do |text| 
+      # Define lambda for each major parsing type: _tostr, _tonode,
+      # boundary constraint _tostr, boundary constraint _node;
+      # and each parsing type will support both normal and N-best
+      # options
+      @parse_tostr = ->(text) {
+        if @options[:nbest] && @options[:nbest] > 1
+          #self.mecab_set_lattice_level(@tagger, (@options[:lattice_level] || 1))
           retval = self.mecab_nbest_sparse_tostr(@tagger, @options[:nbest], text) || 
                 raise(MeCabError.new(self.mecab_strerror(@tagger))) 
-          retval.force_encoding(Encoding.default_external)
-        end 
+        else
+          retval = self.mecab_sparse_tostr(@tagger, text) || 
+                raise(MeCabError.new(self.mecab_strerror(@tagger))) 
+        end
 
-        @parse_tonodes = lambda do |text| 
-          Enumerator.new do |y|
-            self.mecab_nbest_init(@tagger, text) 
-            n = self.mecab_nbest_next_tonode(@tagger)
-            raise(MeCabError.new(self.mecab_strerror(@tagger))) if n.nil? || n.address==0x0
+        retval.force_encoding(Encoding.default_external)
+      } 
 
+      @parse_tonodes = ->(text) { 
+        Enumerator.new do |y|
+          if @options[:nbest] && @options[:nbest] > 1
             nlen = @options[:nbest]
-            nlen.times do |i|
-              s = text.bytes.to_a
-              while n && n.address != 0x0
-                mn = Natto::MeCabNode.new(n)
-                # ignore BOS nodes, since mecab does so
-                if !mn.is_bos?
+            #self.mecab_set_lattice_level(@tagger, (@options[:lattice_level] || 1))
+            self.mecab_nbest_init(@tagger, text) 
+            nptr = self.mecab_nbest_next_tonode(@tagger)
+          else
+            nlen = 1
+            nptr = self.mecab_sparse_tonode(@tagger, text) 
+          end
+          raise(MeCabError.new(self.mecab_strerror(@tagger))) if nptr.nil? || nptr.address==0x0
+
+          nlen.times do
+            s = text.bytes.to_a
+            while nptr && nptr.address != 0x0
+              mn = Natto::MeCabNode.new(nptr)
+              # ignore BOS nodes, since mecab does so
+              if !mn.is_bos?
+                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 = surf.force_encoding(Encoding.default_external)
+                end
+                if @options[:output_format_type] || @options[:node_format]
+                  mn.feature = self.mecab_format_node(@tagger, nptr).force_encoding(Encoding.default_external)
+                end
+                y.yield mn
+              end
+              nptr = mn.next
+            end
+            if nlen > 1
+              nptr = self.mecab_nbest_next_tonode(@tagger)
+            end
+          end
+        end
+      }
+      
+      @bcparse_tostr = ->(text, boundary_constraints=/./) {
+        begin
+          lattice = self.mecab_lattice_new()
+          raise MeCabError.new("Could not create Lattice") if lattice.address == 0x0
+
+          if @options[:nbest] && @options[:nbest] > 1
+            n = @options[:nbest]
+            self.mecab_lattice_set_request_type(lattice, MECAB_LATTICE_NBEST)
+          else
+            n = 1
+            self.mecab_lattice_set_request_type(lattice, MECAB_LATTICE_ONE_BEST)
+          end
+          if @options[:theta]
+            self.mecab_lattice_set_theta(lattice, @options[:theta])
+          end
+
+          tokens = tokenize(text, boundary_constraints)
+          text = tokens.map {|t| t.first}.join
+          self.mecab_lattice_set_sentence(lattice, text)
+
+          bpos = 0
+          tokens.each do |token|
+            c = token.first.bytes.count
+
+            self.mecab_lattice_set_boundary_constraint(lattice, bpos, MECAB_TOKEN_BOUNDARY)
+            bpos += 1
+
+            mark = token.last ? MECAB_INSIDE_TOKEN : MECAB_ANY_BOUNDARY
+            (c-1).times do
+              self.mecab_lattice_set_boundary_constraint(lattice, bpos, mark)
+              bpos += 1
+            end
+          end
+
+          self.mecab_parse_lattice(@tagger, lattice)
+          
+          if n > 1
+            retval = self.mecab_lattice_nbest_tostr(lattice, n)
+          else
+            retval = self.mecab_lattice_tostr(lattice)
+          end
+          retval.force_encoding(Encoding.default_external)
+        rescue
+          raise(MeCabError.new(self.mecab_lattice_strerror(lattice))) 
+        ensure
+          if lattice.address != 0x0
+            self.mecab_lattice_destroy(lattice)
+          end
+        end
+      }
+        
+      @bcparse_tonodes = ->(text, boundary_constraints=/./) {
+        Enumerator.new do |y|
+          begin
+            lattice = self.mecab_lattice_new()
+            raise MeCabError.new("Could not create Lattice") if lattice.address == 0x0
+
+            if @options[:nbest] && @options[:nbest] > 1
+              n = @options[:nbest]
+              self.mecab_lattice_set_request_type(lattice, MECAB_LATTICE_NBEST)
+            else
+              n = 1
+              self.mecab_lattice_set_request_type(lattice, MECAB_LATTICE_ONE_BEST)
+            end
+            if @options[:theta]
+              self.mecab_lattice_set_theta(lattice, @options[:theta])
+            end
+
+            tokens = tokenize(text, boundary_constraints)
+            text = tokens.map {|t| t.first}.join
+            self.mecab_lattice_set_sentence(lattice, text)
+
+            bpos = 0
+            tokens.each do |token|
+              c = token.first.bytes.count
+
+              self.mecab_lattice_set_boundary_constraint(lattice, bpos, MECAB_TOKEN_BOUNDARY)
+              bpos += 1
+
+              mark = token.last ? MECAB_INSIDE_TOKEN : MECAB_ANY_BOUNDARY
+              (c-1).times do
+                self.mecab_lattice_set_boundary_constraint(lattice, bpos, mark)
+                bpos += 1
+              end
+            end
+
+            self.mecab_parse_lattice(@tagger, lattice)
+
+            n.times do
+              check = self.mecab_lattice_next(lattice)
+              if check
+                nptr = self.mecab_lattice_get_bos_node(lattice)
+          
+                s = text.bytes.to_a
+                while nptr && nptr.address!=0x0
+                  mn = Natto::MeCabNode.new(nptr)
                   s = s.drop_while {|e| (e==0xa || e==0x20)}
                   if !s.empty?
                     sarr = []
@@ -224,50 +395,22 @@ module Natto
                     mn.surface = surf.force_encoding(Encoding.default_external)
                   end
                   if @options[:output_format_type] || @options[:node_format]
-                    mn.feature = self.mecab_format_node(@tagger, n).force_encoding(Encoding.default_external)
+                    mn.feature = self.mecab_format_node(@tagger, nptr).force_encoding(Encoding.default_external)
                   end
                   y.yield mn
+                  nptr = mn.next
                 end
-                n = mn.next
               end
-              n = self.mecab_nbest_next_tonode(@tagger)
             end
-          end
-        end
-      else
-        # default parsing implementations
-        @parse_tostr = lambda do |text|
-          retval = self.mecab_sparse_tostr(@tagger, text) || 
-                raise(MeCabError.new(self.mecab_strerror(@tagger))) 
-          retval.force_encoding(Encoding.default_external)
-        end
-
-        @parse_tonodes = lambda do |text| 
-          Enumerator.new do |y|
-            n = self.mecab_sparse_tonode(@tagger, text) 
-            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
-            s = text.bytes.to_a
-            while n && n.address!=0x0
-              mn = Natto::MeCabNode.new(n)
-              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 = surf.force_encoding(Encoding.default_external)
-              end
-              if @options[:output_format_type] || @options[:node_format]
-                mn.feature = self.mecab_format_node(@tagger, n).force_encoding(Encoding.default_external)
-              end
-              y.yield mn
-              n = mn.next
+          rescue
+            raise(MeCabError.new(self.mecab_lattice_strerror(lattice))) 
+          ensure
+            if lattice.address != 0x0
+              self.mecab_lattice_destroy(lattice)
             end
           end
         end
-      end
+      }
 
       @dicts << Natto::DictionaryInfo.new(Natto::Binding.mecab_dictionary_info(@tagger))
       while @dicts.last.next.address != 0x0
@@ -283,17 +426,35 @@ module Natto
     # If a block is passed to this method, then node parsing will be used
     # and each node yielded to the given block.
     #
-    # @param [String] text
+    # Boundary constraint parsing is available via passing in the
+    # `boundary_constraints` key in the `options` hash. Boundary constraints
+    # parsing provides hints to MeCab on where the morpheme boundaries in the
+    # given `text` are located. `boundary_constraints` value may be either a
+    # `Regexp` or `String`; please see
+    # [String#scan](http://ruby-doc.org/core-2.2.0/String.html#method-i-scan String#scan.
+    # The boundary constraint parsed output will be returned as a single
+    # string, unless a block is passed to this method for node parsing.
+    #
+    # @param text [String] the Japanese text to parse
+    # @param options [Hash] only the `boundary_constraints` key is available
     # @return [String] parsing result from `mecab`
     # @raise [MeCabError] if the `mecab` tagger cannot parse the given `text`
     # @raise [ArgumentError] if the given string `text` argument is `nil`
     # @see MeCabNode
-    def parse(text)
+    def parse(text, options={})
       raise ArgumentError.new 'Text to parse cannot be nil' if text.nil?
-      if block_given?
-        @parse_tonodes.call(text).each {|n| yield n }
+      if options[:boundary_constraints]
+        if block_given?
+          @bcparse_tonodes.call(text, options[:boundary_constraints]).each {|n| yield n }
+        else
+          @bcparse_tostr.call(text, options[:boundary_constraints])
+        end
       else
-        @parse_tostr.call(text)
+        if block_given?
+          @parse_tonodes.call(text).each {|n| yield n }
+        else
+          @parse_tostr.call(text)
+        end
       end
     end
 
@@ -301,73 +462,34 @@ module Natto
     # {http://www.ruby-doc.org/core-2.1.5/Enumerator.html Enumerator} that may be
     # used to iterate over the resulting {MeCabNode} objects. This is more 
     # efficient than parsing to a simple string, since each node's
-    # information will not be materialized all at once as with it is with
+    # information will not be materialized all at once as it is with
     # string output.
     #
     # MeCab nodes contain much more detailed information about
     # the morpheme. Node-formatting  may also be used to customize
     # the resulting node's `feature` attribute.
     #
-    # @param [String] text
+    # Boundary constraint parsing is available via passing in the
+    # `boundary_constraints` key in the `options` hash. Boundary constraints
+    # parsing provides hints to MeCab on where the morpheme boundaries in the
+    # given `text` are located. `boundary_constraints` value may be either a
+    # `Regexp` or `String`; please see 
+    # [String#scan](http://ruby-doc.org/core-2.2.0/String.html#method-i-scan String#scan).
+    #
+    # @param text [String] the Japanese text to parse
+    # @param options [Hash] only the `boundary_constraints` key is available
     # @return [Enumerator] of MeCabNode instances
     # @raise [MeCabError] if the `mecab` tagger cannot parse the given `text`
     # @raise [ArgumentError] if the given string `text` argument is `nil`
     # @see MeCabNode
-    # @see http://www.ruby-doc.org/core-2.1.5/Enumerator.html
-    def enum_parse(text)
+    # @see http://ruby-doc.org/core-2.2.1/Enumerator.html
+    def enum_parse(text, options={})
       raise ArgumentError.new 'Text to parse cannot be nil' if text.nil?
-      @parse_tonodes.call(text)
-    end
-
-    # @deprecated
-    # DEPRECATED: use enum_parse instead, this convenience method is useless.
-    # Parses the given string `str`, and returns
-    # a list of `mecab` nodes.
-    # @param [String] str
-    # @return [Array] of parsed `mecab` nodes.
-    # @raise [MeCabError] if the `mecab` tagger cannot parse the given string `str`
-    # @raise [ArgumentError] if the given string `str` argument is `nil`
-    # @see MeCabNode
-    def parse_as_nodes(str)
-      $stderr.puts 'DEPRECATED: use enum_parse instead'
-      $stderr.puts '            This method will be removed in the next release!'
-      raise ArgumentError.new 'String to parse cannot be nil' if str.nil?
-      @parse_tonodes.call(str)
-    end
-
-    # @deprecated
-    # DEPRECATED: use enum_parse instead, this convenience method is useless.
-    # Parses the given string `str`, and returns
-    # a list of `mecab` result strings.
-    # @param [String] str
-    # @return [Array] of parsed `mecab` result strings.
-    # @raise [MeCabError] if the `mecab` tagger cannot parse the given string `str`
-    # @raise [ArgumentError] if the given string `str` argument is `nil`
-    def parse_as_strings(str)
-      $stderr.puts 'DEPRECATED: use enum_parse instead'
-      $stderr.puts '            This method will be removed in the next release!'
-      raise ArgumentError.new 'String to parse cannot be nil' if str.nil?
-      @parse_tostr.call(str).lines.to_a
-    end
-
-    # @deprecated
-    # DEPRECATED: use enum_parse instead, this convenience method is useless.
-    # @param [String] str
-    # @return [Array] of parsed `mecab` nodes.
-    def readnodes(str)
-      $stderr.puts 'DEPRECATED: use enum_parse instead'
-      $stderr.puts '            This method will be removed in the next release!'
-      parse_as_nodes(str)
-    end
-
-    # @deprecated
-    # DEPRECATED: use enum_parse instead, this convenience method is useless.
-    # @param [String] str
-    # @return [Array] of parsed `mecab` result strings.
-    def readlines(str)
-      $stderr.puts 'DEPRECATED: use enum_parse instead'
-      $stderr.puts '            This method will be removed in the next release!'
-      parse_as_strings(str)
+      if options[:boundary_constraints]
+        @bcparse_tonodes.call(text, options[:boundary_constraints])
+      else
+        @parse_tonodes.call(text)
+      end
     end
 
     # Returns human-readable details for the wrapped `mecab` tagger.
@@ -402,17 +524,41 @@ module Natto
     end
 
     # Returns a `Proc` that will properly free resources
-    # when this `MeCab` instance is garbage collected.
+    # when this `Tagger` instance is garbage collected.
     # The `Proc` returned is registered to be invoked
-    # after the `MeCab` instance  owning `ptr` 
+    # after the `Tagger` instance  owning `tptr` 
     # has been destroyed.
     #
-    # @param [FFI::Pointer] ptr
+    # @param tptr [FFI::Pointer] pointer to `Tagger`
     # @return [Proc] to release `mecab` resources properly
-    def self.create_free_proc(ptr)
+    def self.create_free_proc(tptr)
       Proc.new do
-        self.mecab_destroy(ptr)
+        self.mecab_destroy(tptr)
+      end
+    end
+
+    private
+
+    # @private
+    def tokenize(text, pattern)
+      matches = text.scan(pattern)
+      
+      acc =[]
+      tmp = text
+      matches.each_with_index do |m,i|
+        bef, mat, aft = tmp.partition(m)
+        unless bef.empty?
+          acc << [bef.strip, false]
+        end
+        unless mat.empty?
+          acc << [mat.strip, true]
+        end
+        if i==matches.size-1 and !aft.empty?
+          acc << [aft.strip, false]
+        end
+        tmp = aft
       end
+      acc
     end
   end
 

data/lib/natto/option_parse.rb

@@ -97,14 +97,14 @@ module Natto
       # Returns a string-representation of the options to
       # be passed in the construction of the `mecab` tagger.
       #
-      # @param [Hash] options 
+      # @param options[Hash] options for MeCab
       # @return [String] representation of the options to the `mecab` 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
+            if %w( all-morphs allocate-sentence partial ).include? key
               opt << "--#{key}" if options[k]==true
             else
               opt << "--#{key}=#{options[k]}"

data/lib/natto/struct.rb

@@ -6,12 +6,12 @@ module Natto
   require 'ffi'
 
   # `MeCabStruct` is a general base class for `FFI::Struct` objects in
-  # the `Natto` module. Please refer to
-  # [`mecab.h`](http://code.google.com/p/mecab/source/browse/trunk/mecab/src/mecab.h)
+  # the `Natto` module. Please refer to `mecab.h` in the source code
+  # distribution.
   class MeCabStruct < FFI::Struct
     # Provides accessor methods for the members of the `mecab` struct.
     #
-    # @param [String] attr_name
+    # @param attr_name [String] attribute name
     # @return member values for the `mecab` struct
     # @raise [NoMethodError] if `attr_name` is not a member of this `mecab` struct 
     def method_missing(attr_name)
@@ -94,7 +94,7 @@ module Natto
     # Initializes this dictionary info instance.
     # Sets the `DictionaryInfo` filepath value.
     #
-    # @param [FFI::Pointer] ptr pointer to MeCab dictionary
+    # @param ptr [FFI::Pointer] pointer to MeCab dictionary
     def initialize(ptr)
       super(ptr)
 
@@ -246,10 +246,10 @@ module Natto
     # Initializes this node instance.
     # Sets the `MeCab` feature value for this node.
     #
-    # @param [FFI::Pointer] ptr pointer to MeCab node
-    def initialize(ptr)
-      super(ptr)
-      @pointer = ptr
+    # @param nptr [FFI::Pointer] pointer to MeCab node
+    def initialize(nptr)
+      super(nptr)
+      @pointer = nptr
 
       if self[:feature]
         @feature = self[:feature].force_encoding(Encoding.default_external)
@@ -311,10 +311,7 @@ module Natto
     def is_eon?
       self.stat == EON_NODE
     end
-
-
   end
-
 end
 
 # Copyright (c) 2015, Brooke M. Fujita.

data/lib/natto/version.rb

@@ -1,16 +1,16 @@
 # coding: utf-8
 
 # `Natto` is the namespace for objects that provide
-# a binding to the `mecab` tagger and related resources.
+# a binding to MeCab and an API for the `Tagger`,
+# `Node` and `Lattice` objects.
 #
-# `Natto::MeCab` is a wrapper class for the `mecab` 
-# tagger.
+# `Natto::MeCab` is a wrapper class for the MeCab `Tagger`.
 #
 # `Natto::MeCabStruct` is a base class for a `mecab`
 # struct.
 #
 # `Natto::MeCabNode` is a wrapper for the struct representing
-# a `mecab`-parsed node.
+# a MeCab `Node`.
 #
 # `Natto::DictionaryInfo` is a wrapper for the struct 
 # representing a `Natto::MeCab` instance's related 
@@ -27,7 +27,7 @@
 # `Natto`.
 module Natto
   # Version string for this Rubygem.
-  VERSION = "0.9.8"
+  VERSION = "0.9.9"
 end
 
 # Copyright (c) 2015, Brooke M. Fujita.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: natto
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 0.9.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-10 00:00:00.000000000 Z
+date: 2015-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -27,9 +27,41 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.9.0
-description: ! 'No compiler is necessary, as natto is not a C extension. It will run
-  on CRuby (mri/yarv) and JRuby (jvm) equally well. It will also run on Windows, Unix/Linux,
-  and OS X. natto provides a naturally Ruby-esque interface to MeCab.
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: ! 'natto provides a naturally Ruby-esque interface to MeCab. It runs
+  on both CRuby (mri/yarv) and JRuby (jvm). It works with MeCab installations on Windows,
+  Unix/Linux, and OS X. No compiler is necessary, as natto is not a C extension.
 
 '
 email: buruzaemon@gmail.com