mecab-light 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c610ca8725dff12d78f4c8e57aed3a669cb4dfd9
-  data.tar.gz: 2c7400b6c7355e26bf1cf0c11f9dbd9a98401330
+  metadata.gz: ef459849c0f6ac5aa5ec3b00f9d9cb1ccf50a571
+  data.tar.gz: 406118e6f6ea6c5f8e313f0738632d2d92160eb0
 SHA512:
-  metadata.gz: 68e644215d1733e15152650d68923532d20e6cfeae91f0150f1e8b9c9b56503ce42cfc090c9d5cc4f6db26ce971784117d081937d2c61507b8d80c93e9ccaa6d
-  data.tar.gz: df72e4d97b55674761e303e218d8087bf470e9d730be9017eaef8a059bff3a53fbb5c85938f00bc00e79099b6a03e8fb4bac028fafaddc9a408cc5dd4de27cf2
+  metadata.gz: 1364dc10881cb2752311e0872d2edfffe3cd5cc5e84a9070fce6b444afd19f08d76a6ff19cc26b00266de98045758e55dc009f0fb9e774bebbda2189f6abfecf
+  data.tar.gz: c028bc9e01968a4861ef74128e4b6210494a8574b24ee68d5f13f51ba86b4c9f104ba04901ac2174077ca2d34ca4a77fdb841f7031ab8f5aef5408885e177c12

data/.travis.yml

@@ -1,2 +1,5 @@
 rvm:
-- 2.0.0
+- 2.1.0
+notification:
+  emails:
+    - hadzimme@icloud.com

data/lib/mecab/light/morpheme.rb

@@ -2,9 +2,17 @@ module MeCab
   module Light
     class Morpheme
       def initialize(line)
-        @surface, @feature = line.chomp.split(/\t/)
+        @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
-      attr_reader :surface, :feature
     end
   end
 end

data/lib/mecab/light/result.rb

@@ -4,15 +4,30 @@ module MeCab
       include Enumerable
 
       def initialize(parsed)
+        @to_s = parsed
         @morphemes = parsed.each_line.map { |line| Morpheme.new(line) }
       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
+          self.to_enum { @morphemes.size }
         end
       end
 
@@ -21,6 +36,12 @@ module MeCab
       end
 
       alias at []
+
+      def size
+        @morphemes.size
+      end
+
+      alias length size
     end
   end
 end

data/lib/mecab/light/version.rb

@@ -1,5 +1,5 @@
 module MeCab
   module Light
-    VERSION = "0.2.3"
+    VERSION = "0.2.4"
   end
 end

data/spec/mecab-light-morpheme_spec.rb

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

data/spec/mecab-light-result_spec.rb

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

data/spec/mecab-light-tagger_spec.rb

@@ -1,57 +1,79 @@
 require 'spec_helper'
 
 describe MeCab::Light::Tagger do
-  let(:binding) { double( parse_to_s: "surface\tfeature\nEOS\n" ) }
-  let(:result) { double('MeCab::Light::Result') }
-  let(:tagger) { MeCab::Light::Tagger.new }
   before do
     MeCab::Light::Binding.stub(:new).and_return(binding)
     MeCab::Light::Result.stub(:new).and_return(result)
   end
 
-  context 'the class' do
-    it { expect(MeCab::Light::Tagger).to respond_to(:new).with(0).arguments }
+  let :binding do
+    double(MeCab::Light::Binding,
+           parse_to_s: "surface\tfeature\nEOS\n")
+  end
 
-    context 'new' do
-      context 'MeCab::Light::Binding class' do
-        after do
-          MeCab::Light::Tagger.new
-        end
+  let :result do
+    double(MeCab::Light::Result)
+  end
 
-        it 'should receive #new with ""' do
-          expect(MeCab::Light::Binding).to receive(:new).with('')
-        end
-      end
+  describe :new do
+    subject { new }
+
+    let :new do
+      MeCab::Light::Tagger.new
     end
-  end
 
-  context 'an instance' do
-    it { expect(tagger).to respond_to(:parse).with(1).argument }
+    specify do
+      expect(subject).to respond_to(:parse).with(1).argument
+    end
 
-    context 'parse with "surface"' do
-      it 'should be an instance of MeCab::Light::Result' do
-        expect(tagger.parse('surface')).to eq(result)
-      end
+    describe :parse do
+      subject { new.parse(string) }
 
-      context 'MeCab::Light::Result class' do
-        after do
-          tagger.parse('surface')
+      context 'with "surface"' do
+        let :string do
+          'surface'
         end
 
-        it 'should receive #new with "surface\tfeature\n"' do
-          expect(MeCab::Light::Result).to receive(:new).with("surface\tfeature\n")
+        it 'should be an instance of MeCab::Light::Result' do
+          expect(subject).to eq(result)
         end
-      end
 
-      context 'a MeCab::Light::Binding object' do
-        after do
-          tagger.parse('surface')
+        describe MeCab::Light::Result do
+          subject { MeCab::Light::Result }
+
+          before do
+            new.parse(string)
+          end
+
+          specify do
+            expect(subject).to have_received(:new).with("surface\tfeature\n")
+          end
         end
 
-        it 'should receive #parse_to_s with "surface"' do
-          expect(binding).to receive(:parse_to_s).with('surface')
+        describe 'an instance of', MeCab::Light::Binding do
+          subject { binding }
+
+          before do
+            new.parse(string)
+          end
+
+          specify do
+            expect(subject).to have_received(:parse_to_s).with('surface')
+          end
         end
       end
     end
+
+    describe MeCab::Light::Binding do
+      subject { MeCab::Light::Binding }
+
+      before do
+        new
+      end
+
+      specify do
+        expect(subject).to have_received(:new).with('')
+      end
+    end
   end
 end

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: mecab-light
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Hajime WAKAHARA
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-22 00:00:00.000000000 Z
+date: 2014-01-14 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
   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.
@@ -46,8 +46,8 @@ extensions:
 - ext/mecab/light/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -73,17 +73,17 @@ 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: []
 rubyforge_project: 
-rubygems_version: 2.1.9
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: An simple interface for MeCab (UNOFFICIAL)