nimono 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d3cdab19e6fcea0cbe7e9138ffe590c349060643
+  data.tar.gz: ebe278b4338fbfa396cbb985ba30528ca6822998
+SHA512:
+  metadata.gz: ed4637885b7c69a7bec258019f2d414249b34a07332ed81226dbf0408b9c0272d84cca674e6995831addc3c7a286a6b6e2e4587fc8a9a6259189ee60d2a3fa13
+  data.tar.gz: 1d41c5132aa08372c9389056191917c31a60d9b01c3ae56c0049f7cbe8f4c21a038a673cb3efe4b2d95e90823798c77a9f33cb02db9519ea5bcf87c042e78d3d

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*~
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 1.9.3
+before_install: gem install bundler -v 1.13.7

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at opal.s2000@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,85 @@
+# nimono
+
+nimono is an interface of CaboCha for MRI Ruby and JRuby, and parsing Japanese
+sentences using the library.
+It depends on the CaboCha library so the library will have to install first.
+
+## Requirements
+
+nimono requires the following:
+
+- [CaboCha _0.69_](https://taku910.github.io/cabocha/)
+- [CaboCha](https://taku910.github.io/cabocha/) requires [CRF++](https://taku910.github.io/crfpp/), [MeCab](http://taku910.github.io/mecab/#download) and either of the following dictionaries.
+- mecab-ipadic, mecab-jumandic, unidic. For further information please refer to the [MeCab](http://taku910.github.io/mecab/#).
+- [ffi _1.9.0 or higher_](https://rubygems.org/gems/ffi)
+
+## Installation
+
+Install it as:
+
+    $ gem install nimono
+
+## Usage
+
+Create an instance of Nimono::Cabocha and parse the sentence.
+By default, the result is outpeuuted by displaying Sumple Tree.
+
+```ruby
+require 'nimono'
+
+nc = Nimono::Cabocha.new
+puts nc.parse('太郎は花子が読んでいる本を次郎に渡した')
+    太郎は---------D
+      花子が-D     |
+    読んでいる-D   |
+            本を---D
+            次郎に-D
+              渡した
+EOS
+```
+Example of analyzing dependency:
+```ruby
+require 'nimono'
+
+nc = Nimono::Cabocha.new('-n1')
+nc.parse('太郎は花子が読んでいる本を次郎に渡した')
+nc.tokens.each do |t|
+  cid = 0
+  unless t.chunk.nil?
+    puts "* #{cid} #{t.chunk.link}D #{t.chunk.head_pos}/#{t.chunk.func_pos} #{'%6f' % t.chunk.score}"
+    cid += 1
+  end
+  puts "#{t.surface}\t#{t.feature}\t#{t.ne}"
+end
+
+* 0 5D 0/1 -0.742128
+太郎	名詞,固有名詞,人名,名,*,*,太郎,タロウ,タロー	B-PERSON
+は	助詞,係助詞,*,*,*,*,は,ハ,ワ	O
+* 1 2D 0/1 1.700175
+花子	名詞,固有名詞,人名,名,*,*,花子,ハナコ,ハナコ	B-PERSON
+が	助詞,格助詞,一般,*,*,*,が,ガ,ガ	O
+* 2 3D 0/2 1.825021
+読ん	動詞,自立,*,*,五段・マ行,連用タ接続,読む,ヨン,ヨン	O
+で	助詞,接続助詞,*,*,*,*,で,デ,デ	O
+いる	動詞,非自立,*,*,一段,基本形,いる,イル,イル	O
+* 3 5D 0/1 -0.742128
+本	名詞,一般,*,*,*,*,本,ホン,ホン	O
+を	助詞,格助詞,一般,*,*,*,を,ヲ,ヲ	O
+* 4 5D 1/2 -0.742128
+次	名詞,一般,*,*,*,*,次,ツギ,ツギ	O
+郎	名詞,一般,*,*,*,*,郎,ロウ,ロー	O
+に	助詞,格助詞,一般,*,*,*,に,ニ,ニ	O
+* 5 -1D 0/1 0.000000
+渡し	動詞,自立,*,*,五段・サ行,連用形,渡す,ワタシ,ワタシ	O
+た	助動詞,*,*,*,特殊・タ,基本形,た,タ,タ	O
+
+```
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/TakayoshiYamazaki/nimono. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nimono"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/nimono.rb

@@ -0,0 +1,3 @@
+#-*- coding:utf-8 -*-
+require 'nimono/nimono'
+

data/lib/nimono/cabocha_lib.rb

@@ -0,0 +1,293 @@
+#-*- coding: utf-8 -*-
+module Nimono
+
+  # Module `CabochaLib` is a ruby extension for CaboCha libraries using Ruby-FFI.
+  module CabochaLib
+    require 'ffi'
+    extend FFI::Library
+
+    CABOCHA_PATH = 'CABOCHA_PATH'.freeze
+
+    # @private
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    # Returns the absolute path to the CaboCha library.
+    # @return [String] absolute path to the CaboCha library
+    def self.cabocha_library
+      if ENV[CABOCHA_PATH]
+        File.absolute_path(ENV[CABOCHA_PATH])
+      else
+        host_os = RbConfig::CONFIG['host_os'].downcase
+
+        lib_name = case host_os
+                   when /mswin|mingw/ # /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+                     require 'win32/registry'
+                     begin
+                       path = nil
+                       Win32::Registry::HKEY_CURRENT_USER.open('Software\Cabocha') {|r| path = r['cabocharc'].split('etc').first}
+                       File.join(path, "bin\\libcabocha.dll")
+                     rescue
+                       raise LoadError, "Please set #{CABOCHA_PATH} to the full path to libcabocha.dll"
+                     end
+                   when /darwin/, /linux/, /solaris|bsd/
+                     require 'open3'
+                     host_os =~ /darwin/ ? ext = 'dylib' : ext = 'so'
+                     begin
+                       Open3.popen3('cabocha-config --libs') {|i, o, e, t|
+                         i.close
+                         tokens = o.read.split
+                         File.absolute_path(File.join(tokens[0][2..-1], "lib#{tokens[1][2..-1]}.#{ext}"))
+                       }
+                     rescue
+                       raise LoadError, "Please set #{CABOCHA_PATH} to the full path to libcabocha.#{ext}"
+                     end
+                   else
+                     raise CabochaError.new "unknown os: #{host_os.inspect}"
+                   end
+      end
+    end
+
+    begin
+      ffi_lib cabocha_library
+    rescue LoadError => e
+      raise LoadError, "Faild to load CaboCha Library, patches appreciated! (#{e.message})"
+    end
+
+    # parser interfaces
+    attach_function :cabocha_new2, [:string], :pointer
+    attach_function :cabocha_destroy, [:pointer], :void
+    # attach_function :cabocha_parse_tree, [:pointer, :pointer], :pointer
+    attach_function :cabocha_sparse_tostr, [:pointer, :pointer], :string
+    attach_function :cabocha_sparse_totree, [:pointer, :pointer], :pointer
+
+    # tree interfaces
+    # attach_function :cabocha_tree_new, [], :pointer
+    attach_function :cabocha_tree_destroy, [:pointer], :void
+    # attach_function :cabocha_tree_set_output_layer, [:pointer, :int], :void
+    attach_function :cabocha_tree_tostr, [:pointer, :int], :string
+    attach_function :cabocha_tree_size, [:pointer], :size_t
+    attach_function :cabocha_tree_chunk_size, [:pointer], :size_t
+    attach_function :cabocha_tree_token_size, [:pointer], :size_t
+    attach_function :cabocha_tree_token, [:pointer, :size_t], :pointer
+    attach_function :cabocha_tree_chunk, [:pointer, :size_t], :pointer
+    # attach_function :cabocha_tree_charset, [:pointer], :int
+    # attach_function :cabocha_tree_posset, [:pointer], :int
+
+
+    # @private
+    module ClassMethods
+      def cabocha_library
+        Nimono::CabochaLib.cabocha_library
+      end
+      # Create parser
+      # @param opt_str [String] the option for CaboCha
+      def cabocha_new2(opt_str)
+        Nimono::CabochaLib.cabocha_new2(opt_str)
+      end
+      # Destroy parser
+      # @param pptr [#parser] parser instance #parser
+      def cabocha_destroy(pptr)
+        Nimono::CabochaLib.cabocha_destroy(pptr)
+      end
+
+      # def cabocha_parse_tree(pptr, tptr)
+      #   Nimono::CabochaLib.cabocha_parse_tree(pptr, tptr)
+      # end
+
+      # Create tree
+      # @param pptr [#parser] instance of parser #parser
+      # @param sptr [String] text for parsing
+      def cabocha_sparse_tostr(pptr, sptr)
+        Nimono::CabochaLib.cabocha_sparse_tostr(pptr, sptr)
+      end
+
+      def cabocha_sparse_totree(pptr, sptr)
+        Nimono::CabochaLib.cabocha_sparse_totree(pptr, sptr)
+      end
+
+      # tree
+      # def cabocha_tree_new
+      #   Nimono::CabochaLib.cabocha_tree_new
+      # end
+
+      # def cabocha_tree_destory(tptr)
+      #   Nimono::CabochaLib.cabocha_tree_destroy(tptr)
+      # end
+
+      # def cabocha_tree_set_output_layer(tptr, n)
+      #   Nimono::CabochaLib.cabocha_tree_set_output_layer(tptr, n)
+      # end
+
+      def cabocha_tree_tostr(tptr, n)
+        Nimono::CabochaLib.cabocha_tree_tostr(tptr, n)
+      end
+
+      def cabocha_tree_size(tptr)
+        Nimono::CabochaLib.cabocha_tree_size(tptr)
+      end
+
+      def cabocha_tree_chunk_size(tptr)
+        Nimono::CabochaLib.cabocha_tree_chunk_size(tptr)
+      end
+
+      def cabocha_tree_token_size(tptr)
+        Nimono::CabochaLib.cabocha_tree_token_size(tptr)
+      end
+
+      # # convert Tree to Sentence
+      # def cabocha_tree_sentence(tptr)
+      #   Nimono::CabochaLib.cabocha_tree_sentence(tptr)
+      # end
+
+      #
+      # @param [#tree] tree instance tree
+      # @param [Fixnum] 
+      def cabocha_tree_token(tptr, n)
+        Nimono::CabochaLib.cabocha_tree_token(tptr, n)
+      end
+
+      def cabocha_tree_chunk(tptr, n)
+        Nimono::CabochaLib.cabocha_tree_chunk(tptr, n)
+      end
+
+      # def cabocha_tree_charset(tptr)
+      #   Nimono::CabochaLib.cabocha_tree_charset(tptr)
+      # end
+
+      # def cabocha_tree_posset(tptr)
+      #   Nimono::CabochaLib.cabocha_tree_posset(tptr)
+      # end
+
+    end
+  end
+
+
+  # 'Chunk' is a wrapper class for the 'cabocha_chunk_t' structure.
+  class Chunk < FFI::Struct
+    attr_reader :link
+    attr_reader :head_pos
+    attr_reader :func_pos
+    attr_reader :token_size
+    attr_reader :token_pos
+    attr_reader :score
+    attr_reader :feature_list
+    attr_reader :additional_info
+    attr_reader :feature_list_size
+
+    # :features is a hash of elements of :feature_list separated by colons.
+    attr_reader :features
+
+    layout :link, :int,
+           :head_pos, :size_t,
+           :func_pos, :size_t,
+           :token_size, :size_t,
+           :token_pos, :size_t,
+           :score, :float,
+           :feature_list, :pointer,
+           :additional_info, :string,
+           :feature_list_size, :ushort
+
+    def initialize(lptr)
+      super(lptr)
+      @pointer = lptr
+      if self[:additional_info]
+        @additional_info = self[:additional_info].force_encoding(Encoding.default_external)
+      end
+      if self[:link]
+        @link = self[:link]
+      end
+      if self[:head_pos]
+        @head_pos = self[:head_pos]
+      end
+      if self[:func_pos]
+        @func_pos = self[:func_pos]
+      end
+      if self[:token_size]
+        @token_size = self[:token_size]
+      end
+      if self[:token_pos]
+        @token_pos = self[:token_pos]
+      end
+      if self[:score]
+        @score = self[:score]
+      end
+      if self[:feature_list_size]
+        @feature_list_size = self[:feature_list_size]
+      end
+
+      if self[:feature_list_size] < 0
+        raise CabochaError.new "Feature list size error"
+      else
+        if self[:feature_list].null?
+          @feature_list = [].freeze
+        else
+          @feature_list = self[:feature_list].get_array_of_string(0, self[:feature_list_size]).each{|s| s.force_encoding(Encoding.default_external)}.freeze
+
+          # create a new hash from @feature_list
+          @features = Hash[*@feature_list.map {|f| f.split(':') }.flatten].freeze
+        end
+      end
+    end
+  end
+
+  # 'Token' is a wrapper class for the 'cabocha_token_t' structure.
+  class Token < FFI::Struct
+    attr_reader :surface
+    attr_reader :normalized_surface
+    attr_reader :feature
+    attr_reader :feature_list
+    attr_reader :feature_list_size
+    attr_reader :ne
+    attr_reader :additional_info
+    attr_reader :chunk
+
+    layout :surface, :string,
+           :normalized_surface, :string,
+           :feature, :string,
+           :feature_list, :pointer,
+           :feature_list_size, :ushort,
+           :ne, :string,
+           :additional_info, :string,
+           :chunk, :pointer
+
+    def initialize(lptr)
+      super(lptr)
+      @pointer = lptr
+      if self[:surface]
+        @surface = self[:surface].force_encoding(Encoding.default_external)
+      end
+      if self[:normalized_surface]
+        @normalized_surface = self[:normalized_surface].force_encoding(Encoding.default_external)
+      end
+      if self[:feature]
+        @feature = self[:feature].force_encoding(Encoding.default_external)
+      end
+      if self[:feature_list_size]
+        @feature_list_size = self[:feature_list_size]
+      end
+      if self[:ne]
+        @ne = self[:ne].force_encoding(Encoding.default_external)
+      end
+      if self[:additional_info]
+        @additional_info = self[:additional_info].force_encoding(Encoding.default_external)
+      end
+      if self[:chunk]
+        self[:chunk].null? ? nil : @chunk = Nimono::Chunk.new(self[:chunk])
+      end
+
+      if self[:feature_list_size] < 0
+        raise CabochaError.new "Feature list size error"
+      else
+        if self[:feature_list].null?
+          @feature_list = [].freeze
+        else
+          @feature_list = self[:feature_list].get_array_of_string(0, self[:feature_list_size]).each{|s| s.force_encoding(Encoding.default_external)}.freeze
+        end
+      end
+
+    end
+  end
+
+end

data/lib/nimono/nimono.rb

@@ -0,0 +1,154 @@
+#-*- coding: utf-8 -*-
+require 'nimono/option_parse'
+require 'nimono/cabocha_lib'
+require 'nimono/version'
+
+module Nimono
+
+  # `Cabocha` is a class providing an interface to the CaboCha library.
+  # In this class the arguments supported by CaboCha can be used in almost
+  # the same way.
+  class Cabocha
+    include Nimono::OptionParse
+    include Nimono::CabochaLib
+
+    # @return [Hash] CaboCha options as Key-Value pairs
+    attr_reader :options
+    # @return [String] absolute file path to CaboCha library
+    attr_reader :libpath
+    # @return [Array] Array of chunk
+    attr_reader :chunks
+    # 
+    # @return [Array] Array of Token
+    attr_reader :tokens
+
+    # Initializes the CaboCha with the given 'options'.
+    # options is given as a string (CaboCha command line arguments) or
+    # as a Ruby-style hash.
+    #
+    # Options supported are:
+    #
+    # - :output_format
+    # - :input_layer
+    # - :output_layer
+    # - :ne
+    # - :parser_model
+    # - :chunker_model
+    # - :ne_model
+    # - :posset
+    # - :charset
+    # - :charset_file
+    # - :rcfile
+    # - :mecabrc
+    # - :mecab_dicdir
+    # - :mecab_userdic
+    # - :output
+    #
+    # <p>CaboCha command line arguments (-f1) or long (--output-format=1) may
+    # be used in addition ot Ruby-style hashs</p>
+    #
+    # e.g.<br />
+    #
+    #   require 'nimono'
+    #
+    #   nc = Nimono::Cabocha.new(output_format: 1)
+    #   or nc = Nimono::Cabocha.new('-f1')
+    #
+    #   => #<Nimono::Cabocha:0x6364e48d
+    #     @sparse_tostr=#<Proc:0x74d917f5@/home/foo/nimono/lib/nimono/nimono.rb:54 (lambda)>,
+    #     @libpath="/usr/local/lib/libcabocha.so",
+    #     @options={:output_format=>1},
+    #     @tree=#<FFI::Pointer address=0x7f6ecc2e3790>,
+    #     @parser=#<FFI::Pointer address=0x7f6ecc2e3830>>
+    #
+    #   puts nc.parse('太郎は花子が読んでいる本を次郎に渡した')
+    #   太郎    名詞,固有名詞,人名,名,*,*,太郎,タロウ,タロー
+    #   は      助詞,係助詞,*,*,*,*,は,ハ,ワ
+    #   * 1 2D 0/1 1.700175
+    #   花子    名詞,固有名詞,人名,名,*,*,花子,ハナコ,ハナコ
+    #   が      助詞,格助詞,一般,*,*,*,が,ガ,ガ
+    #   * 2 3D 0/2 1.825021
+    #   読ん    動詞,自立,*,*,五段・マ行,連用タ接続,読む,ヨン,ヨン
+    #   で      助詞,接続助詞,*,*,*,*,で,デ,デ
+    #   いる    動詞,非自立,*,*,一段,基本形,いる,イル,イル
+    #   * 3 5D 0/1 -0.742128
+    #   本      名詞,一般,*,*,*,*,本,ホン,ホン
+    #   を      助詞,格助詞,一般,*,*,*,を,ヲ,ヲ
+    #   * 4 5D 1/2 -0.742128
+    #   次      名詞,一般,*,*,*,*,次,ツギ,ツギ
+    #   郎      名詞,一般,*,*,*,*,郎,ロウ,ロー
+    #   に      助詞,格助詞,一般,*,*,*,に,ニ,ニ
+    #   * 5 -1D 0/1 0.000000
+    #   渡し    動詞,自立,*,*,五段・サ行,連用形,渡す,ワタシ,ワタシ
+    #   た      助動詞,*,*,*,特殊・タ,基本形,た,タ,タ
+    #   EOS
+    #   => nil
+    #
+    # @param options [Hash, String] the CaboCha options
+    # @raise [CabochaError] if Cabocha cannot be initialized with the given 'options'
+    def initialize(options={})
+      @options = self.class.parse_options(options)
+      opt_str = self.class.build_options_str(@options)
+      @libpath = self.class.cabocha_library
+
+      @parser = self.class.cabocha_new2(opt_str)
+      if @parser.address == 0x0
+        raise CabochaError.new("Could not initialize CaboCha with options: '#{opt_str}'")
+      end
+      @tree = self.class.cabocha_sparse_totree(@parser, "")
+
+      if @options[:output_layer]
+        self.class.cabocha_tree_set_output_layer(@tree, @options[:output_layer])
+      end
+
+      @sparse_tostr = ->(text) {
+        begin
+          self.class.cabocha_sparse_tostr(@parser, text).force_encoding(Encoding.default_external)
+        rescue
+          raise CabochaError.new 'Parse Error'
+        end
+      }
+    end
+
+    # Parses the given `text`, returning the CaboCha output as a string.
+    # At the same time creating #chunks and #tokens.
+    # @param text [String] the japanese text to parse
+    # @return [String] parsing result from CaoboCha
+    # @raise [CabochaError] if the Cabocha cannot parse the given `text`
+    # @raise [ArgumentError] if the given string `text` argument is `null`
+    def parse(text)
+      if text.nil?
+        raise CabochaError.new 'Text to parse cannot be nil'
+      else
+        @result = @sparse_tostr.call(text)
+        @tree = self.class.cabocha_sparse_totree(@parser, text)
+
+        @tokens = []
+        self.class.cabocha_tree_token_size(@tree).times do |i|
+          @tokens << Nimono::Token.new(self.class.cabocha_tree_token(@tree, i))
+        end
+        @tokens.freeze
+
+        @chunks = []
+        self.class.cabocha_tree_chunk_size(@tree).times do |i|
+          @chunks << Nimono::Chunk.new(self.class.cabocha_tree_chunk(@tree, i))
+          # chunk = Nimono::Chunk.new(self.class.cabocha_tree_chunk(@tree, i))
+          # chunk.instance_variable_set(:@tokens, @tokens[chunk.token_pos..(chunk.token_pos + chunk.token_size - 1)])
+          # @chunks << chunk
+        end
+        @chunks.freeze
+
+        self.to_s
+      end
+    end
+
+    # The result of parsing Japanese text
+    # @return [String] parsing result
+    def to_s
+      @result
+    end
+
+  end
+
+  class CabochaError < RuntimeError; end
+end

data/lib/nimono/option_parse.rb

@@ -0,0 +1,106 @@
+#-*- coding: utf-8 -*-
+module Nimono
+
+  # Module 'OptionParse' encapsulates methods and behavior
+  # for parsing the various CaboCha options supported by 'Nimono'.
+  module OptionParse
+    require 'optparse'
+
+    # Supported CaboCha command line options are as follows.
+    # For further information please refer to CaboCha help.
+    SUPPORT_OPTS = {
+      '-f' => :output_format,
+      '-I' => :input_layer,
+      '-O' => :output_layer,
+      '-n' => :ne,
+      '-m' => :parser_model,
+      '-M' => :chunker_model,
+      '-N' => :ne_model,
+      '-P' => :posset,
+      '-t' => :charset,
+      '-T' => :charset_file,
+      '-r' => :rcfile,
+      '-b' => :mecabrc,
+      '-d' => :mecab_dicdir,
+      '-u' => :mecab_userdic,
+      '-o' => :output
+    }.freeze
+
+    # @private
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    # @private
+    module ClassMethods
+
+      # Preparesand returns a hash mapping symbols for the specified,
+      # recognized CaboCha options, and their values. Will parse and
+      # convert string (short or long argument styles) or hash.
+      def parse_options(options={})
+        opts = {}
+        if options.is_a? String
+          opt = OptionParser.new
+          opt.on('-f', '--output-format=VAL') {|v| opts[:output_format] = v.strip }
+          opt.on('-I', '--input-layer=VAL') {|v| opts[:input_layer] = v.strip }
+          opt.on('-O', '--output-layer=VAL') {|v| opts[:output_layer] = v.strip }
+          opt.on('-n', '--ne=VAL') {|v| opts[:ne] = v.strip }
+          opt.on('-m', '--parser-model=VAL') {|v| opts[:parser_model] = v.strip }
+          opt.on('-M', '--chunker-model=VAL') {|v| opts[:chunker_model] = v.strip }
+          opt.on('-N', '--ne-model=VAL') {|v| opts[:ne_model] = v.strip }
+          opt.on('-P', '--posset=VAL') {|v| opts[:posset] = v.strip }
+          opt.on('-t', '--charset=VAL') {|v| opts[:charset] = v.strip }
+          opt.on('-T', '--charset-file=VAL') {|v| opts[:posset] = v.strip }
+          opt.on('-r', '--rcfile=VAL') {|v| opts[:rcfile] = v.strip }
+          opt.on('-b', '--mecabrc=VAL') {|v| opts[:mecabrc] = v.strip }
+          opt.on('-d', '--mecab-dicdir=VAL') {|v| opts[:posset] = v.strip }
+          opt.on('-u', '--mecab-userdic=VAL') {|v| opts[:posset] = v.strip }
+          opt.on('-o', '--output=VAL') {|v| opts[:output] = v.strip }
+          opt.parse!(options.split)
+        else
+          SUPPORT_OPTS.values.each do |k|
+            if options.has_key?(k)
+              opts[k] = options[k]
+            end
+          end
+        end
+
+        # validation
+        validate_numeric = ->(name, pattern) {
+          if opts.has_key?(name)
+            if opts[name].is_a?(String) && opts[name] =~ pattern
+              opts[name] = opts[name].to_i
+            elsif opts[name].is_a?(Fixnum) && opts[name].to_s =~ pattern
+            else
+              v = opts[name]
+              name_str = name.id2name.gsub('_', '-')
+              raise CabochaError.new("Invalid option: --#{name_str}=#{v}")
+            end
+          end
+        }
+
+        validate_numeric.(:output_format, /^[0-4]$/)
+        validate_numeric.(:input_layer,   /^[0-3]$/)
+        validate_numeric.(:output_layer,  /^[1-4]$/)
+        validate_numeric.(:ne,            /^[0-2]$/)
+
+        opts
+      end
+
+      # Returns a string representation of the options to
+      # be passed in the construction of the CaboCha Paser.
+      # @param options[Hash] options for CaboCha
+      # @return [String] representation of the options to the CaboCha Parser
+      def build_options_str(options={})
+        opt = []
+        SUPPORT_OPTS.values.each do |k|
+          if options.has_key? k
+            key = k.to_s.gsub('_', '-')
+            opt << "--#{key}=#{options[k]}"
+          end
+        end
+        opt.empty? ? '' : opt.join(" ")
+      end
+    end
+  end
+end

data/lib/nimono/version.rb

@@ -0,0 +1,4 @@
+#-*- coding: utf-8 -*-
+module Nimono
+  VERSION = "0.1.5"
+end

data/nimono.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nimono/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nimono"
+  spec.version       = Nimono::VERSION
+  spec.authors       = ["Takayoshi Yamazaki"]
+  spec.email         = ["opal.s2000@gmail.com"]
+
+  spec.summary       = %q{nimono is a interface to CaboCha.}
+  spec.description   = %q{nimono is a interface to CaboCha for CRuby(mri/yarv)
+   and JRuby(jvm). It depends on the CaboCha library so the library will have 
+   to install first.}
+  spec.homepage      = "https://github.com/TakayoshiYamazaki/nimono"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.9'
+  spec.requirements << 'CaboCha 0.69'
+  spec.add_runtime_dependency "ffi", ">= 1.9.0"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: nimono
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Takayoshi Yamazaki
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: "nimono is a interface to CaboCha for CRuby(mri/yarv)\n   and JRuby(jvm).
+  It depends on the CaboCha library so the library will have \n   to install first."
+email:
+- opal.s2000@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/nimono.rb
+- lib/nimono/cabocha_lib.rb
+- lib/nimono/nimono.rb
+- lib/nimono/option_parse.rb
+- lib/nimono/version.rb
+- nimono.gemspec
+homepage: https://github.com/TakayoshiYamazaki/nimono
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- CaboCha 0.69
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: nimono is a interface to CaboCha.
+test_files: []