mecab-light 0.2.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6aa33f0ee97f8aded6bc38e67033d43da422141
-  data.tar.gz: b16db2fcd1952748c63e52c41183aa4978875ed8
+  metadata.gz: 905b46000c4f3aa2da1252ee10f01f5cd44cfc6a
+  data.tar.gz: ffde14f8a056e8dfa9dde57900ca6e08fc6da0ad
 SHA512:
-  metadata.gz: d5ba2232c0a925e51c612668e398afd23652048d5bbd6b271501ba207f4114eb79b257fdfb49ca9c7b1df3de02972d0d420b98b846f56ed3447425752ad7631b
-  data.tar.gz: e227388d67336d480ed47fa31839edd1c64ea39a42eb01dc21e216cbe1f1208fa837f27b751bc6d7d5d5ec5a08756d2024c10bafd7164c9bce6d55fea2ab558a
+  metadata.gz: 1cf53d9d1d3e27cd74531190423193cba4ddae9ed334ae3b61250ab92038eeab789b671ee64d32f47034bcb77d2acfc0072a0adec109b17a19ac8ce5f6b9d686
+  data.tar.gz: 902dc3c3a94f117f8bb548300b6c4c151fa8d9d3dae6698f37a320a56b13c92f3b40f4a19fad02cec65018208223b048943ffd6b93575bec0a7555f315bfdd03

data/README.md

@@ -1,11 +1,5 @@
 # MeCab::Light
 
-[![Gem Version](https://badge.fury.io/rb/mecab-light.png)][gem]
-[![Build Status](https://travis-ci.org/hadzimme/mecab-light.png)][travis]
-[![Coverage Status](https://coveralls.io/repos/hadzimme/mecab-light/badge.png?branch=master)][coveralls]
-[![Code Climate](https://codeclimate.com/github/hadzimme/mecab-light.png)][codeclimate]
-[![Dependency Status](https://gemnasium.com/hadzimme/mecab-light.png)][gemnasium]
-
 [gem]: http://badge.fury.io/rb/mecab-light
 [travis]: https://travis-ci.org/hadzimme/mecab-light
 [coveralls]: https://coveralls.io/r/hadzimme/mecab-light?branch=master
@@ -28,24 +22,34 @@ Or install it yourself as:
 
     $ gem install mecab-light
 
+Install on Windows:
+
+    $ gem install mecab-light -- --with-mecab-folder=C:/MeCab # assign yours
+
 ## Usage
 
 ```ruby
 require 'mecab/light'
 
-tagger = MeCab::Light::Tagger.new
+tagger = MeCab::Light::Tagger.new('')
 string = 'この文を形態素解析してください。'
 result = tagger.parse(string)
-result[0].surface #=> "この"
 result.kind_of?(Enumerable) #=> true
 result.map(&:surface)
 #=> ["この", "文", "を", "形態素", "解析", "し", "て", "ください", "。"]
+
+model = MeCab::Light::Model.new('')
+tagger = MeCab::Light::Tagger.new(model)
+lattice = MeCab::Light::Lattice.new(model)
+lattice.sentence = 'この文を形態素解析してください。'
+result = tagger.parse(lattice)
+result.map(&:surface)
+#=> ["この", "文", "を", "形態素", "解析", "し", "て", "ください", "。"]
 ```
 
 MeCab::Light is a lightweight tool.
 This gem works without the official binding.
-This supports only Tagger#parse method for now.
-Note that the method's feature is totally different from its original.
+Note that this supports less methods than those of C API for now.
 
 ## Contributing
 

data/Rakefile

@@ -1,11 +1,10 @@
 require "bundler/gem_tasks"
 
 Bundler.setup
-require 'rspec/core/rake_task'
 
-desc 'run spec'
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = ["-c", "-fs"]
+desc 'Run test'
+
+task :test do
 end
 
-task :default => :spec
+task :default => :test

data/ext/mecab/{light/extconf.rb → extconf.rb}

@@ -4,10 +4,10 @@ if mecab_dir = arg_config('--with-mecab-folder')
   sdk_dir = File.join(mecab_dir, 'sdk')
   bin_dir = File.join(mecab_dir, 'bin')
   if find_header('mecab.h', sdk_dir) && find_library('mecab', nil, bin_dir)
-    create_makefile('mecab/light/binding')
+    create_makefile('mecab/light')
   end
 else
   if have_header('mecab.h') && have_library('mecab')
-    create_makefile('mecab/light/binding')
+    create_makefile('mecab/light')
   end
 end

data/ext/mecab/light.c

@@ -0,0 +1,227 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <mecab.h>
+
+#define MECAB_LIGHT_MAJOR_VERSION 1
+#define MECAB_LIGHT_MINOR_VERSION 0
+#define MECAB_LIGHT_PATCH_VERSION 0
+
+typedef struct {
+  mecab_model_t* ptr;
+} Model;
+
+typedef struct {
+  mecab_t* ptr;
+} Tagger;
+
+typedef struct {
+  mecab_lattice_t* ptr;
+  rb_encoding* enc;
+} Lattice;
+
+typedef struct {
+  const mecab_node_t* ptr;
+  rb_encoding* enc;
+} Node;
+
+typedef struct {
+  const mecab_node_t* bos_node;
+  rb_encoding* enc;
+} Result;
+
+static VALUE
+name_space()
+{
+  VALUE rb_mMeCab = rb_define_module("MeCab");
+  return rb_define_module_under(rb_mMeCab, "Light");
+}
+
+static void
+model_free(Model* model)
+{
+  mecab_model_destroy(model->ptr);
+}
+
+static VALUE
+model_alloc(VALUE klass)
+{
+  Model* model = ALLOC(Model);
+  return Data_Wrap_Struct(klass, 0, model_free, model);
+}
+
+static void
+tagger_free(Tagger* tagger)
+{
+  mecab_destroy(tagger->ptr);
+}
+
+static VALUE
+tagger_alloc(VALUE klass)
+{
+  Tagger* tagger = ALLOC(Tagger);
+  return Data_Wrap_Struct(klass, 0, tagger_free, tagger);
+}
+
+static void
+lattice_free(Lattice* lattice)
+{
+  mecab_lattice_destroy(lattice->ptr);
+}
+
+static VALUE
+lattice_alloc(VALUE klass)
+{
+  Lattice* lattice = ALLOC(Lattice);
+  return Data_Wrap_Struct(klass, 0, lattice_free, lattice);
+}
+
+static VALUE
+rb_model_initialize(VALUE self, VALUE arg)
+{
+  Model* model;
+
+  Data_Get_Struct(self, Model, model);
+  model->ptr = mecab_model_new2(RSTRING_PTR(arg));
+  return Qnil;
+}
+
+static VALUE
+rb_tagger_initialize(VALUE self, VALUE arg)
+{
+  Tagger* tagger;
+  Model* model;
+  VALUE class_of_arg, rb_cModel;
+
+  Data_Get_Struct(self, Tagger, tagger);
+  rb_cModel = rb_define_class_under(name_space(), "Model", rb_cObject);
+  class_of_arg = CLASS_OF(arg);
+  if (class_of_arg == rb_cString) {
+    tagger->ptr = mecab_new2(RSTRING_PTR(arg));
+  } else if (class_of_arg == rb_cModel) {
+    Data_Get_Struct(arg, Model, model);
+    tagger->ptr = mecab_model_new_tagger(model->ptr);
+  } else {
+    rb_raise(rb_eTypeError, "The argument should be String or MeCab::Light::Model");
+  }
+  return Qnil;
+}
+
+static VALUE
+rb_tagger_parse(VALUE self, VALUE arg)
+{
+  Tagger* tagger;
+  Lattice* lattice;
+  Result* result = ALLOC(Result);
+  VALUE class_of_arg, rb_cLattice, rb_cResult;
+
+  Data_Get_Struct(self, Tagger, tagger);
+  rb_cLattice = rb_define_class_under(name_space(), "Lattice", rb_cObject);
+  class_of_arg = CLASS_OF(arg);
+  if (class_of_arg == rb_cString) {
+    result->bos_node = mecab_sparse_tonode(tagger->ptr, RSTRING_PTR(arg));
+    result->enc = rb_enc_get(arg);
+  } else if (class_of_arg == rb_cLattice) {
+    Data_Get_Struct(arg, Lattice, lattice);
+    mecab_parse_lattice(tagger->ptr, lattice->ptr);
+    result->bos_node = mecab_lattice_get_bos_node(lattice->ptr);
+    result->enc = lattice->enc;
+  } else {
+    rb_raise(rb_eTypeError, "The argument should be String or MeCab::Light::Lattice");
+  }
+  rb_cResult = rb_define_class_under(name_space(), "Result", rb_cObject);
+  return Data_Wrap_Struct(rb_cResult, 0, 0, result);
+}
+
+static VALUE
+rb_lattice_initialize(VALUE self, VALUE rb_model)
+{
+  Lattice* lattice;
+  Model* model;
+
+  Data_Get_Struct(self, Lattice, lattice);
+  Data_Get_Struct(rb_model, Model, model);
+  lattice->ptr = mecab_model_new_lattice(model->ptr);
+  return Qnil;
+}
+
+static VALUE
+rb_lattice_set_sentence(VALUE self, VALUE str)
+{
+  Lattice* lattice;
+
+  Data_Get_Struct(self, Lattice, lattice);
+  mecab_lattice_set_sentence(lattice->ptr, RSTRING_PTR(str));
+  lattice->enc = rb_enc_get(str);
+  return str;
+}
+
+static VALUE
+result_enum_length(VALUE self, VALUE args, VALUE eobj)
+{
+  return rb_funcall(self, rb_intern("count"), 0);
+}
+
+static VALUE
+rb_result_each(VALUE self)
+{
+  Result* result;
+  Node* node;
+  VALUE rb_cNode;
+
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, result_enum_length);
+  Data_Get_Struct(self, Result, result);
+  node = ALLOC(Node);
+  node->ptr = result->bos_node->next;
+  node->enc = result->enc;
+  rb_cNode = rb_define_class_under(name_space(), "Node", rb_cObject);
+  for (; node->ptr->next; node->ptr = node->ptr->next) {
+    rb_yield(Data_Wrap_Struct(rb_cNode, 0, 0, node));
+  }
+  return self;
+}
+
+static VALUE
+rb_node_get_surface(VALUE self)
+{
+  Node* node;
+  VALUE surface;
+
+  Data_Get_Struct(self, Node, node);
+  surface = rb_str_new(node->ptr->surface, node->ptr->length);
+  return rb_enc_associate(surface, node->enc);
+}
+
+static VALUE
+rb_node_get_feature(VALUE self)
+{
+  Node* node;
+  VALUE feature;
+
+  Data_Get_Struct(self, Node, node);
+  feature = rb_str_new2(node->ptr->feature);
+  return rb_enc_associate(feature, node->enc);
+}
+
+void
+Init_light()
+{
+  VALUE rb_cModel, rb_cLattice, rb_cTagger, rb_cNode, rb_cResult;
+
+  rb_cModel = rb_define_class_under(name_space(), "Model", rb_cObject);
+  rb_cTagger = rb_define_class_under(name_space(), "Tagger", rb_cObject);
+  rb_cLattice = rb_define_class_under(name_space(), "Lattice", rb_cObject);
+  rb_cNode = rb_define_class_under(name_space(), "Node", rb_cObject);
+  rb_cResult = rb_define_class_under(name_space(), "Result", rb_cObject);
+  rb_define_alloc_func(rb_cModel, model_alloc);
+  rb_define_alloc_func(rb_cTagger, tagger_alloc);
+  rb_define_alloc_func(rb_cLattice, lattice_alloc);
+  rb_define_private_method(rb_cModel, "initialize", rb_model_initialize, 1);
+  rb_define_private_method(rb_cTagger, "initialize", rb_tagger_initialize, 1);
+  rb_define_private_method(rb_cLattice, "initialize", rb_lattice_initialize, 1);
+  rb_define_method(rb_cTagger, "parse", rb_tagger_parse, 1);
+  rb_define_method(rb_cLattice, "sentence=", rb_lattice_set_sentence, 1);
+  rb_define_method(rb_cResult, "each", rb_result_each, 0);
+  rb_define_method(rb_cNode, "surface", rb_node_get_surface, 0);
+  rb_define_method(rb_cNode, "feature", rb_node_get_feature, 0);
+  rb_include_module(rb_cResult, rb_mEnumerable);
+}

data/mecab-light.gemspec

@@ -1,11 +1,24 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'mecab/light/version'
+base_dir = File.dirname(__FILE__)
+ext_dir = File.join(base_dir, 'ext', 'mecab')
+
+guess_version = lambda do |ext_dir|
+  version = {}
+
+  File.open(File.join(ext_dir, 'light.c')) do |light_c|
+    light_c.each_line do |line|
+      case line
+      when /\A#define MECAB_LIGHT_([A-Z]+)_VERSION (\d+)/
+        version[$1.intern] = $2
+      end
+    end
+  end
+
+  [version[:MAJOR], version[:MINOR], version[:PATCH]].join('.')
+end
 
 Gem::Specification.new do |gem|
   gem.name          = "mecab-light"
-  gem.version       = MeCab::Light::VERSION
+  gem.version       = guess_version.call(ext_dir)
   gem.authors       = ["Hajime Wakahara"]
   gem.email         = ["hadzimme@icloud.com"]
   gem.description   = %q{Use a sequence of morphemes as an Enumerable object.}
@@ -16,11 +29,9 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-  gem.required_ruby_version = '>= 1.9'
-  gem.extensions << 'ext/mecab/light/extconf.rb'
+  gem.required_ruby_version = '>= 2.0'
+  gem.extensions << 'ext/mecab/extconf.rb'
 
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'simplecov'
-  gem.add_development_dependency 'coveralls'
+  gem.add_development_dependency 'test-unit'
 end

metadata

@@ -1,69 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: mecab-light
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Hajime Wakahara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-30 00:00:00.000000000 Z
+date: 2014-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Use a sequence of morphemes as an Enumerable object.
@@ -71,27 +43,18 @@ email:
 - hadzimme@icloud.com
 executables: []
 extensions:
-- ext/mecab/light/extconf.rb
+- ext/mecab/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- ext/mecab/light/binding.c
-- ext/mecab/light/extconf.rb
-- lib/mecab/light.rb
-- lib/mecab/light/morpheme.rb
-- lib/mecab/light/result.rb
-- lib/mecab/light/tagger.rb
-- lib/mecab/light/version.rb
+- ext/mecab/extconf.rb
+- ext/mecab/light.c
 - mecab-light.gemspec
-- spec/mecab-light-morpheme_spec.rb
-- spec/mecab-light-result_spec.rb
-- spec/mecab-light-tagger_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/hadzimme/mecab-light
 licenses: []
 metadata: {}
@@ -101,22 +64,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '1.9'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.3.0
 signing_key: 
 specification_version: 4
 summary: An simple interface for MeCab (UNOFFICIAL)
-test_files:
-- spec/mecab-light-morpheme_spec.rb
-- spec/mecab-light-result_spec.rb
-- spec/mecab-light-tagger_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/ext/mecab/light/binding.c

@@ -1,50 +0,0 @@
-#include <ruby.h>
-#include <ruby/encoding.h>
-#include <mecab.h>
-
-typedef struct {
-  mecab_t* ptr;
-} MeCab;
-
-static VALUE
-mecab_alloc(VALUE klass)
-{
-  MeCab* mecab = ALLOC(MeCab);
-  return Data_Wrap_Struct(klass, 0, 0, mecab);
-}
-
-static VALUE
-rb_mecab_initialize(VALUE self, VALUE arg)
-{
-  MeCab* mecab;
-
-  Data_Get_Struct(self, MeCab, mecab);
-  mecab->ptr = mecab_new2(RSTRING_PTR(arg));
-  return Qnil;
-}
-
-static VALUE
-rb_mecab_parse_to_s(VALUE self, VALUE str)
-{
-  MeCab* mecab;
-  const char* result;
-  rb_encoding* enc;
-
-  Data_Get_Struct(self, MeCab, mecab);
-  enc = rb_enc_get(str);
-  result = mecab_sparse_tostr(mecab->ptr, RSTRING_PTR(str));
-  return rb_enc_associate(rb_str_new2(result), enc);
-}
-
-void
-Init_binding()
-{
-  VALUE rb_mMeCab, rb_mLight, rb_cBinding;
-
-  rb_mMeCab = rb_define_module("MeCab");
-  rb_mLight = rb_define_module_under(rb_mMeCab, "Light");
-  rb_cBinding = rb_define_class_under(rb_mLight, "Binding", rb_cObject);
-  rb_define_alloc_func(rb_cBinding, mecab_alloc);
-  rb_define_private_method(rb_cBinding, "initialize", rb_mecab_initialize, 1);
-  rb_define_method(rb_cBinding, "parse_to_s", rb_mecab_parse_to_s, 1);
-}

data/lib/mecab/light/morpheme.rb

@@ -1,18 +0,0 @@
-module MeCab
-  module Light
-    class Morpheme
-      def initialize(line)
-        @to_s = line.chomp
-        @surface, @feature = @to_s.split(/\t/)
-      end
-
-      alias to_s_orig to_s
-      private :to_s_orig
-      attr_reader :surface, :feature, :to_s
-
-      def inspect
-        to_s_orig.sub(/>$/, " #{@to_s}>")
-      end
-    end
-  end
-end

data/lib/mecab/light/result.rb

@@ -1,51 +0,0 @@
-module MeCab
-  module Light
-    class Result
-      include Enumerable
-
-      def initialize(parsed)
-        @to_s = parsed
-        @morphemes = []
-
-        parsed.each_line do |line|
-          @morphemes << Morpheme.new(line)
-        end
-      end
-
-      def to_one_line
-        @morphemes.map do |morpheme|
-          morpheme.surface
-        end.join(' ')
-      end
-
-      alias to_s_orig to_s
-      private :to_one_line, :to_s_orig
-      attr_reader :to_s
-
-      def inspect
-        to_s_orig.sub(/>$/, " #{to_one_line}>")
-      end
-
-      def each(&block)
-        if block_given?
-          @morphemes.each(&block)
-          self
-        else
-          self.to_enum { @morphemes.size }
-        end
-      end
-
-      def [](nth)
-        @morphemes[nth]
-      end
-
-      alias at []
-
-      def size
-        @morphemes.size
-      end
-
-      alias length size
-    end
-  end
-end

data/lib/mecab/light/tagger.rb

@@ -1,18 +0,0 @@
-module MeCab
-  module Light
-    class Tagger
-      def initialize
-        @mecab = Binding.new('')
-      end
-
-      def parse(string)
-        Result.new(parse_to_s(string))
-      end
-
-      private
-      def parse_to_s(string)
-        @mecab.parse_to_s(string).sub(/EOS\n$/, '')
-      end
-    end
-  end
-end

data/lib/mecab/light/version.rb

@@ -1,5 +0,0 @@
-module MeCab
-  module Light
-    VERSION = "0.2.5"
-  end
-end

data/lib/mecab/light.rb

@@ -1,5 +0,0 @@
-require 'mecab/light/version'
-require 'mecab/light/morpheme'
-require 'mecab/light/result'
-require 'mecab/light/tagger'
-require 'mecab/light/binding'

data/spec/mecab-light-morpheme_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe MeCab::Light::Morpheme do
-  subject do
-    MeCab::Light::Morpheme.new(line)
-  end
-
-  context 'initialized with "surface\tfeature\n"' do
-    let :line do
-      "surface\tfeature\n"
-    end
-
-    specify do
-      expect(subject).to respond_to(:surface).with(0).arguments
-    end
-
-    specify do
-      expect(subject).to respond_to(:feature).with(0).arguments
-    end
-
-    describe :surface do
-      let :surface do
-        subject.surface
-      end
-
-      specify do
-        expect(surface).to eq('surface')
-      end
-
-      describe :encoding do
-        let :encoding do
-          surface.encoding
-        end
-
-        specify do
-          expect(encoding).to eq(Encoding::UTF_8)
-        end
-      end
-    end
-
-    describe :feature do
-      let :feature do
-        subject.feature
-      end
-
-      specify do
-        expect(feature).to eq('feature')
-      end
-
-      describe :encoding do
-        let :encoding do
-          feature.encoding
-        end
-
-        specify do
-          expect(encoding).to eq(Encoding::UTF_8)
-        end
-      end
-    end
-
-    describe :to_s do
-      let :to_s do
-        subject.to_s
-      end
-
-      specify do
-        expect(to_s).to eq("surface\tfeature")
-      end
-
-      describe :encoding do
-        let :encoding do
-          to_s.encoding
-        end
-
-        specify do
-          expect(encoding).to eq(Encoding::UTF_8)
-        end
-      end
-    end
-
-    describe :inspect do
-      let :inspect do
-        subject.inspect
-      end
-
-      specify do
-        pattern = /^#<MeCab::Light::Morpheme:\w+ surface\tfeature>$/
-        expect(inspect).to match(pattern)
-      end
-    end
-  end
-end

data/spec/mecab-light-result_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-describe MeCab::Light::Result do
-  before do
-    MeCab::Light::Morpheme.stub(:new).and_return(morpheme)
-  end
-
-  let :morpheme do
-    double(MeCab::Light::Morpheme,
-           surface: 'surface',
-           feature: 'feature')
-  end
-
-  subject do
-    MeCab::Light::Result.new(parsed)
-  end
-
-  context 'initialized with "surface\tfeature\n"' do
-    let :parsed do
-      "surface\tfeature\n"
-    end
-
-    specify do
-      expect(subject).to respond_to(:each).with(0).arguments
-    end
-
-    specify do
-      expect(subject).to be_an(Enumerable)
-    end
-
-    describe :each do
-      let :each do
-        subject.each(&block)
-      end
-
-      context 'with block' do
-        let :block do
-          lambda { |morpheme| }
-        end
-
-        it 'should return self' do
-          expect(each).to eq(subject)
-        end
-
-        specify do
-          expect { |b| subject.each(&b) }.to yield_control
-        end
-
-        it 'should yield with args(MeCab::Light::Morpheme)' do
-          expect { |b| subject.each(&b) }.to yield_with_args(morpheme)
-        end
-      end
-
-      context 'without block' do
-        let :block do
-          nil
-        end
-
-        specify do
-          expect(each).to be_an_instance_of(Enumerator)
-        end
-
-        describe :size do
-          let :size do
-            each.size
-          end
-
-          specify do
-            expect(size).to eq(1)
-          end
-        end
-      end
-    end
-
-    describe :count do
-      let :count do
-        subject.count
-      end
-
-      specify do
-        expect(count).to eq(1)
-      end
-    end
-
-    describe :size do
-      let :size do
-        subject.size
-      end
-
-      specify do
-        expect(size).to eq(1)
-      end
-    end
-
-    describe :length do
-      let :length do
-        subject.length
-      end
-
-      specify do
-        expect(length).to eq(1)
-      end
-    end
-
-    describe :[] do
-      let :at_literal do
-        subject[nth]
-      end
-
-      context 'with 0' do
-        let :nth do
-          0
-        end
-
-        it 'should be an instance of Morpheme' do
-          expect(at_literal).to eq(morpheme)
-        end
-      end
-    end
-
-    describe :at do
-      let :at do
-        subject.at(nth)
-      end
-
-      context 'with 0' do
-        let :nth do
-          0
-        end
-
-        it 'should be an instance of Morpheme' do
-          expect(at).to eq(morpheme)
-        end
-      end
-    end
-
-    describe :inspect do
-      let :inspect do
-        subject.inspect
-      end
-
-      specify do
-        expect(inspect).to match(/^#<MeCab::Light::Result:\w+ surface>$/)
-      end
-    end
-  end
-end

data/spec/mecab-light-tagger_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe MeCab::Light::Tagger do
-  before do
-    MeCab::Light::Binding.stub(:new).and_return(binding)
-    MeCab::Light::Result.stub(:new).and_return(result)
-  end
-
-  let :binding do
-    double(MeCab::Light::Binding,
-           parse_to_s: "surface\tfeature\nEOS\n")
-  end
-
-  let :result do
-    double(MeCab::Light::Result)
-  end
-
-  specify do
-    expect(subject).to respond_to(:parse).with(1).argument
-  end
-
-  describe :parse do
-    let :parse do
-      subject.parse(string)
-    end
-
-    context 'with "surface"' do
-      let :string do
-        'surface'
-      end
-
-      it 'should be an instance of MeCab::Light::Result' do
-        expect(parse).to eq(result)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,22 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-Coveralls.wear!
-formatters = [
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter,
-]
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[*formatters]
-
-SimpleCov.start do
-  add_filter 'spec'
-end
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'mecab/light/morpheme'
-require 'mecab/light/result'
-require 'mecab/light/tagger'
-
-
-class MeCab::Light::Binding
-end