langue-japanese 0.0.2

data/lib/langue/japanese/words/classifier.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+module Langue
+  module Japanese
+    module Classifier
+      {
+
+        # noun
+        :noun                  => %w(名詞),
+        :noncategorematic_noun => %w(名詞 非自立),
+        :noun_conjunct_to_suru => %w(名詞 サ変接続),
+        :adverbable_noun       => %w(名詞 副詞可能),
+        :adjective_stem_noun   => %w(名詞 形容動詞語幹),
+        :pronoun               => %w(名詞 代名詞),
+
+        # adjective
+        :categorematic_adjective    => %w(形容詞 自立),
+        :noncategorematic_adjective => %w(形容詞 非自立),
+
+        # verb
+        :categorematic_verb    => %w(動詞 自立),
+        :noncategorematic_verb => %w(動詞 非自立),
+
+        # auxiliary verb
+        :auxiliary_verb => %w(助動詞),
+
+        # particle
+        :conjunctive_particle => %w(助詞 接続助詞),
+
+        # prefix
+        :noun_prefix      => %w(接頭詞 名詞接続),
+        :adjective_prefix => %w(接頭詞 形容詞接続),
+        :verb_prefix      => %w(接頭詞 動詞接続),
+
+        # suffix
+        :noun_suffix           => %w(名詞 接尾),
+        :adjective_stem_suffix => %w(名詞 接尾 形容動詞語幹),
+        :adjective_suffix      => %w(形容詞 接尾),
+        :verb_suffix           => %w(動詞 接尾),
+
+        # symbol
+        :symbol   => %w(記号),
+        :alphabet => %w(記号 アルファベット)
+
+      }.each do |category, categories|
+        define_method("#{category}?") do |morphemes, index|
+          morphemes.at(index) { |m| m.classified?(*categories) }
+        end
+      end
+
+      def first_noun?(morphemes, index)
+         noun?(morphemes, index)                  &&
+        !pronoun?(morphemes, index)               &&
+        !adverbable_noun?(morphemes, index)       &&
+        !noun_suffix?(morphemes, index)           &&
+        !noncategorematic_noun?(morphemes, index)
+      end
+
+      def first_verb?(morphemes, index)
+        categorematic_verb?(morphemes, index) && morphemes.at(index) do |m|
+          !%w(する なる 思う おもう).include?(m.root_form)
+        end
+      end
+
+      def first_adjective?(morphemes, index)
+        categorematic_adjective?(morphemes, index)
+      end
+
+      def following_noun?(morphemes, index)
+         noun?(morphemes, index)            &&
+        !pronoun?(morphemes, index)         &&
+        !adverbable_noun?(morphemes, index)
+      end
+
+      def following_adjective?(morphemes, index)
+        (noncategorematic_adjective?(morphemes, index) || adjective_suffix?(morphemes, index)) ||
+        auxiliary_verb?(morphemes, index)
+      end
+
+      def following_verb?(morphemes, index)
+        (noncategorematic_verb?(morphemes, index) || verb_suffix?(morphemes, index)) ||
+        auxiliary_verb?(morphemes, index)
+      end
+
+      def following_symbol?(morphemes, index)
+        alphabet?(morphemes, index)
+      end
+
+      def suru_verb?(morphemes, index)
+        categorematic_verb?(morphemes, index) && morphemes.at(index) { |m| m.inflected?('サ変・スル') }
+      end
+
+      def body_verb?(morphemes, index)
+        categorematic_verb?(morphemes, index) || noncategorematic_verb?(morphemes, index) && !progressive_verb?(morphemes, index)
+      end
+
+      def progressive_verb?(morphemes, index)
+        noncategorematic_verb?(morphemes, index) && morphemes.at(index) do |m|
+          %w(いる てる でる とる どる ちゃう じゃう).include?(m.root_form)
+        end
+      end
+
+      def body_adjective?(morphemes, index)
+        categorematic_adjective?(morphemes, index) || noncategorematic_adjective?(morphemes, index)
+      end
+    end
+  end
+end

data/lib/langue/japanese/words/morpheme_filter.rb

@@ -0,0 +1,26 @@
+module Langue
+  module Japanese
+    module MorphemeFilter
+      def self.included(object)
+        return if object.respond_to?(:filter)
+
+        object.class_eval do
+          def body_morphemes
+            @body_morphemes ||= self.class.filters.inject(self) { |morphemes, filter| filter[self, morphemes] }
+          end
+
+          class << self
+            def filters
+              @filters ||= []
+            end
+
+            def filter(&filter)
+              remove_instance_variable(:@body_morphemes) if instance_variable_defined?(:@body_morphemes)
+              filters << filter
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langue/japanese/words/noun.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+require 'langue/word'
+require 'langue/japanese/words/classifier'
+
+module Langue
+  module Japanese
+    class Noun < Word
+      INHIBITED_FIRST_CHARS = %w(ぁ ァ ぃ ィ ぅ ゥ ぇ ェ ぉ ォ っ ッ ー)
+      INHIBITED_LAST_CHARS  = %w()
+
+      class << self
+        include Classifier
+
+        def take(morphemes, index)
+          if first_noun?(morphemes, index)
+            take_noun(morphemes, index)
+          elsif noun_prefix?(morphemes, index)
+            take_noun_with_prefix(morphemes, index)
+          elsif adverbable_noun?(morphemes, index)
+            take_adverbable_noun(morphemes, index)
+          else
+            0
+          end
+        end
+
+        def take_noun(morphemes, index)
+          return 0 unless first_noun?(morphemes, index)
+          all = adjective_stem_noun?(morphemes, index)
+          size = 1
+
+          while following_noun?(morphemes, index + size) || following_symbol?(morphemes, index + size)
+            all &&= adjective_stem_noun?(morphemes, index + size)
+            size += 1
+          end
+
+          return 0 if all
+          return 0 if noun_conjunct_to_suru?(morphemes, index + size - 1) && suru_verb?(morphemes, index + size)
+          first_char = morphemes[index].text[0]
+          last_char = morphemes[index + size - 1].text[-1]
+          return 0 if INHIBITED_FIRST_CHARS.include?(first_char)
+          return 0 if INHIBITED_LAST_CHARS.include?(last_char)
+          size
+        end
+
+        def take_noun_with_prefix(morphemes, index)
+          size = 0
+          size += 1 while noun_prefix?(morphemes, index + size)
+          return 0 unless size > 0
+          next_size = take_noun(morphemes, index + size)
+          next_size > 0 ? size + next_size : 0
+        end
+
+        def take_adverbable_noun(morphemes, index)
+          size = 0
+          size += 1 while adverbable_noun?(morphemes, index + size)
+          size
+        end
+      end
+    end
+  end
+end

data/lib/langue/japanese/words/period.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+require 'langue/word'
+require 'langue/japanese/words/classifier'
+
+module Langue
+  module Japanese
+    class Period < Word
+      COMMAS = %w(, ， 、)
+      DOTS   = COMMAS + %w(. ． 。 ・ ‥ …)
+      MARKS  = %w(! ！ ? ？)
+
+      class << self
+        def take(morphemes, index)
+          if dot?(morphemes, index)
+            take_dot(morphemes, index)
+          elsif mark?(morphemes, index)
+            take_mark(morphemes, index)
+          else
+            0
+          end
+        end
+
+        def dot?(morphemes, index)
+          morphemes.at(index) { |m| DOTS.include?(m.text) }
+        end
+
+        def mark?(morphemes, index)
+          morphemes.at(index) { |m| MARKS.include?(m.text) }
+        end
+
+        def take_dot(morphemes, index)
+          size = 0
+          size += 1 while dot?(morphemes, index + size)
+          size == 1 && COMMAS.include?(morphemes[index].text) ? 0 : size
+        end
+
+        def take_mark(morphemes, index)
+          size = 0
+          size += 1 while mark?(morphemes, index + size)
+          size
+        end
+      end
+
+      def exclamation?
+        @exclamation = !!(text =~ /[!！]/) unless instance_variable_defined?(:@exclamation)
+        @exclamation
+      end
+
+      def question?
+        @question = !!(text =~ /[?？]/) unless instance_variable_defined?(:@question)
+        @question
+      end
+    end
+  end
+end

data/lib/langue/japanese/words/prefix.rb

@@ -0,0 +1,19 @@
+require 'langue/japanese/words/morpheme_filter'
+
+module Langue
+  module Japanese
+    module Prefix
+      def self.included(object)
+        object.class_eval do
+          include MorphemeFilter
+          filter { |word, morphemes| morphemes[word.prefix_morphemes.size..-1] }
+        end
+      end
+
+      def prefix
+        @prefix = prefix_morphemes.map(&:text).join unless instance_variable_defined?(:@prefix)
+        @prefix
+      end
+    end
+  end
+end

data/lib/langue/japanese/words/pronoun.rb

@@ -0,0 +1,16 @@
+require 'langue/japanese/words/noun'
+require 'langue/japanese/words/classifier'
+
+module Langue
+  module Japanese
+    class Pronoun < Noun
+      class << self
+        include Classifier
+
+        def take(morphemes, index)
+          pronoun?(morphemes, index) ? 1 : 0
+        end
+      end
+    end
+  end
+end

data/lib/langue/japanese/words/verb.rb

@@ -0,0 +1,100 @@
+require 'langue/word'
+require 'langue/japanese/words/prefix'
+require 'langue/japanese/words/attribute'
+require 'langue/japanese/words/classifier'
+
+module Langue
+  module Japanese
+    class Verb < Word
+      include Prefix
+      include Attribute
+
+      has :progressive, :passive, :aggressive, :negative, :perfective, :imperative
+
+      class << self
+        include Classifier
+
+        def take(morphemes, index)
+          if first_verb?(morphemes, index)
+            take_verb(morphemes, index)
+          elsif verb_prefix?(morphemes, index)
+            take_verb_with_prefix(morphemes, index)
+          elsif first_noun?(morphemes, index)
+            take_noun_conjunct_to_suru(morphemes, index)
+          elsif noun_prefix?(morphemes, index)
+            take_noun_with_prefix_conjunct_to_suru(morphemes, index)
+          else
+            0
+          end
+        end
+
+        def take_verb(morphemes, index)
+          return 0 unless first_verb?(morphemes, index)
+          take_following_verb(morphemes, index)
+        end
+
+        def take_verb_with_prefix(morphemes, index)
+          size = 0
+          size += 1 while verb_prefix?(morphemes, index + size)
+          return 0 unless size > 0
+          next_size = take_verb(morphemes, index + size)
+          next_size > 0 ? size + next_size : 0
+        end
+
+        def take_noun_conjunct_to_suru(morphemes, index)
+          size = 0
+          size += 1 while following_noun?(morphemes, index + size)
+          return 0 unless size > 0
+          return 0 unless noun_conjunct_to_suru?(morphemes, index + size - 1)
+          return 0 unless suru_verb?(morphemes, index + size)
+          size + take_following_verb(morphemes, index + size)
+        end
+
+        def take_noun_with_prefix_conjunct_to_suru(morphemes, index)
+          size = 0
+          size += 1 while noun_prefix?(morphemes, index + size)
+          return 0 unless size > 0
+          next_size = take_noun_conjunct_to_suru(morphemes, index + size)
+          next_size > 0 ? size + next_size : 0
+        end
+
+        private
+
+        def take_following_verb(morphemes, index)
+          size = 1
+          size += 1 while following_verb?(morphemes, index + size) || conjunctive_particle?(morphemes, index + size) && following_verb?(morphemes, index + size + 1)
+          size += 1 while auxiliary_verb?(morphemes, index + size)
+          size
+        end
+      end
+
+      def key_morpheme
+        unless instance_variable_defined?(:@key_morpheme)
+          @key_morpheme = if empty?
+                            nil
+                          else
+                            index = size - 1
+                            index -= 1 while !self.class.body_verb?(morphemes, index)
+                            self[index]
+                          end
+        end
+
+        @key_morpheme
+      end
+
+      def prefix_morphemes
+        @prefix_morphemes ||= begin
+                                size = 0
+
+                                if self.class.verb_prefix?(morphemes, size)
+                                  size += 1 while self.class.verb_prefix?(morphemes, size)
+                                elsif self.class.noun_prefix?(morphemes, size)
+                                  size += 1 while self.class.noun_prefix?(morphemes, size)
+                                end
+
+                                morphemes[0, size]
+                              end
+      end
+    end
+  end
+end

data/lib/langue/japanese.rb

@@ -0,0 +1,2 @@
+require 'langue/japanese/version'
+require 'langue/japanese/language'

data/lib/langue-japanese.rb

@@ -0,0 +1 @@
+require 'langue/japanese'

data/spec/langue/japanese/data.yaml

@@ -0,0 +1,169 @@
+-
+  text: 今日は妹と一緒にお買い物してきたよ。楽しかった〜
+  sentences:
+    -
+      - [今日, Noun]
+      - [妹, Noun]
+      - [一緒, Noun]
+      - - お買い物してきた
+        - Verb
+        - body: 買い物してくる
+          prefix: お
+          attributes: [perfective]
+      - [。, Period]
+    -
+      - - 楽しかった
+        - Adjective
+        - body: 楽しい
+          attributes: [perfective]
+
+-
+  text: 例の女子会が延期になってちょっとホッとしている
+  sentences:
+    -
+      - [例, Noun]
+      - [女子会, Noun]
+      - [延期, Noun]
+
+-
+  text: こんなに部屋が寒くてはインターネットもままならぬ
+  sentences:
+    -
+      - [部屋, Noun]
+      - - 寒く
+        - Adjective
+        - body: 寒い
+      - [インターネット, Noun]
+
+-
+  text: 牛乳って意外と甘い？
+  sentences:
+    -
+      - [牛乳, Noun]
+      - - 甘い
+        - Adjective
+        - body: 甘い
+      - [？, Period]
+
+-
+  text: むしろ精神的疾患とは……
+  sentences:
+    -
+      - [精神的疾患, Noun]
+      - [……, Period]
+
+-
+  text: 情報系大学生なら卒業までに応用情報レベルの知識を習っていると思うのだけども.
+  sentences:
+    -
+      - [情報系大学生, Noun]
+      - [卒業, Noun]
+      - [応用情報レベル, Noun]
+      - [知識, Noun]
+      - - 習っている
+        - Verb
+        - body: 習う
+          attributes: [progressive]
+      - [., Period]
+
+-
+  text: プログラマーの資格を持つ息子が面接に全て落ちました。理系でも旧帝じゃないとダメなのでしょうか？
+  sentences:
+    -
+      - [プログラマー, Noun]
+      - [資格, Noun]
+      - - 持つ
+        - Verb
+        - body: 持つ
+      - [息子, Noun]
+      - [面接, Noun]
+      - [全て, Noun]
+      - - 落ちました
+        - Verb
+        - body: 落ちる
+          attributes: [perfective]
+      - [。, Period]
+    -
+      - [理系, Noun]
+      - [旧帝, Noun]
+      - [ダメ, AdjectiveNoun]
+      - [？, Period]
+
+-
+  text: ちゃんと病院いこうね…。はい…。
+  sentences:
+    -
+      - [病院, Noun]
+      - - いこう
+        - Verb
+        - body: いく
+      - […。, Period]
+    -
+      - […。, Period]
+
+-
+  text: んー、お昼がスープパスタだけとか。。。あふんあふん。。。後で絶対お腹すくなー。でも今あんま食べる気しにゃい。。。
+  sentences:
+    -
+      - [お昼, Noun]
+      - [スープパスタ, Noun]
+      - [。。。, Period]
+    -
+      - [あふん, Verb]
+      - [。。。, Period]
+    -
+      - [絶対, Noun]
+      - [お腹, Noun]
+      - - すく
+        - Adjective
+        - body: すい
+      - [。, Period]
+    -
+      - [今あんま, Noun]
+      - - 食べる
+        - Verb
+        - body: 食べる
+      - [しにゃい, Verb]
+      - [。。。, Period]
+
+-
+  text: iPhone 4Sにただで替えられるって聞いたけど、本当に使うかは疑問なので……
+  sentences:
+    -
+      - [iphone4s, Noun]
+      - [ただ, Noun]
+      - - 替えられる
+        - Verb
+        - body: 替える
+          attributes: [passive]
+      - - 聞いた
+        - Verb
+        - body: 聞く
+          attributes: [perfective]
+      - - 使う
+        - Verb
+        - body: 使う
+      - [疑問, Noun]
+      - [……, Period]
+
+-
+  text: 俺のためにご奉仕しろ！
+  sentences:
+    -
+      - [俺, Pronoun]
+      - - ご奉仕しろ
+        - Verb
+        - body: 奉仕する
+          prefix: ご
+          attributes: [imperative]
+      - [！, Period]
+
+-
+  text: 風と共に去らぬ
+  sentences:
+    -
+      - [風, Noun]
+      - - 去らぬ
+        - Verb
+        - body: 去る
+          attributes: [negative]

data/spec/langue/japanese/language_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'langue/japanese/language'
+
+describe Langue::Japanese::Language do
+  it 'is an instance of Class' do
+    described_class.should be_an_instance_of(Class)
+  end
+
+  it 'extends Langue::Language' do
+    described_class.superclass.should == Langue::Language
+  end
+end
+
+describe Langue::Japanese::Language, '#parser' do
+  before do
+    @language = described_class.new(:key => 'value')
+  end
+
+  it 'calls Langue::Japanese::Parser.new with the options' do
+    parser_stub
+    Langue::Japanese::Parser.should_receive(:new).with(:key => 'value')
+    @language.parser
+  end
+
+  it 'returns an instance of Langue::Japanese::Parser' do
+    parser = parser_stub
+    @language.parser.should == parser
+  end
+end
+
+describe Langue::Japanese::Language, '#shaper' do
+  before do
+    @language = described_class.new(:key => 'value')
+  end
+
+  it 'calls Langue::Japanese::Shaper.new with the options' do
+    shaper_stub
+    Langue::Japanese::Shaper.should_receive(:new).with(:key => 'value')
+    @language.shaper
+  end
+
+  it 'returns an instance of Langue::Japanese::Shaper' do
+    shaper = shaper_stub
+    @language.shaper.should == shaper
+  end
+end
+
+describe Langue::Japanese::Language, '#structurer' do
+  before do
+    @language = described_class.new(:key => 'value')
+  end
+
+  it 'calls Langue::Japanese::Structurer.new with the options' do
+    structurer_stub
+    Langue::Japanese::Structurer.should_receive(:new).with(:key => 'value')
+    @language.structurer
+  end
+
+  it 'returns an instance of Langue::Japanese::Structurer' do
+    structurer = structurer_stub
+    @language.structurer.should == structurer
+  end
+end
+
+describe Langue::Japanese::Language, '#parse' do
+  before do
+    @language = described_class.new(:key => 'value')
+  end
+
+  it 'calls parse method of parser with a text' do
+    parser_stub do |m|
+      m.should_receive(:parse).with('text')
+    end
+
+    @language.parse('text')
+  end
+
+  it 'returns the value returning from Langue::Japanese::Parser#parse' do
+    parser_stub
+    @language.parse('text').should == 'value returning from parse method'
+  end
+end
+
+describe Langue::Japanese::Language, '#shape_person_name' do
+  before do
+    @language = described_class.new(:key => 'value')
+  end
+
+  it 'calls shape_person_name method of shaper with morphemes' do
+    shaper_stub do |m|
+      m.should_receive(:shape_person_name).with('morphemes', 'Akane')
+    end
+
+    @language.shape_person_name('morphemes', 'Akane')
+  end
+
+  it 'returns the value returning from Langue::Japanese::Shaper#shape_person_name' do
+    shaper_stub
+    @language.shape_person_name('morphemes', 'Akane').should == 'value returning from shape_person_name method'
+  end
+end
+
+describe Langue::Japanese::Language, '#structure' do
+  before do
+    @language = described_class.new(:key => 'value')
+  end
+
+  it 'calls structure method of structurer with morphemes' do
+    structurer_stub do |m|
+      m.should_receive(:structure).with('morphemes')
+    end
+
+    @language.structure('morphemes')
+  end
+
+  it 'returns the value returning from Langue::Japanese::Structurer#structure' do
+    structurer_stub
+    @language.structure('morphemes').should == 'value returning from structure method'
+  end
+end