japanese_deinflector 0.0.1 → 0.0.2

data/lib/deinflect_to_json.rb

@@ -13,20 +13,21 @@ def parse(fpath)
     # Rules are tab-separated in the following format:
     # <from>\t<to>\t<type>\t<reason_index>
     else
-      from = parts.first
-      rules_hash[from.size] ||= []
-      rules_hash[from.size] << {
-        :from => from,
-        :to => parts[1],
-        :reason_id => parts[3].to_i
+      from_suffix = parts.first
+      reason_id = parts[3].to_i
+      rules_hash[from_suffix.size] ||= []
+      rules_hash[from_suffix.size] << {
+        :from_suffix => from_suffix,
+        :to_suffix => parts[1],
+        :reason => reasons[reason_id],
       }
     end
   end
-
-  {:reasons => reasons, :rules => rules_hash}
+  rules_hash
 end
 
 root = File.expand_path(File.dirname(__FILE__))
 File.open(File.join(root, 'data/deinflect.json'), 'w') do |f|
-  f.write(parse(File.join(root, 'data/deinflect.dat')).to_json)
+  parsed_dat = parse(File.join(root, 'data/deinflect.dat'))
+  f.write(JSON.pretty_generate(parsed_dat))
 end

data/lib/japanese_deinflector.rb

@@ -1,41 +1,65 @@
 #encoding: utf-8
+require 'rubygems'
 require 'json'
 require "japanese_deinflector/version"
 
 class JapaneseDeinflector
   def initialize
     File.open(File.join(File.expand_path(File.dirname(__FILE__)), 'data/deinflect.json')) do |f|
-      rules_and_reasons = JSON.parse(f.read, :symbolize_names => true)
-      @reasons = rules_and_reasons[:reasons]
-      # Convert hash keys to integers
-      @rules = {}
-      # Convert hash keys from something like :"9" -> 9
-      rules_and_reasons[:rules].each do |size, rules|
-        @rules[size.to_s.to_i] = rules
+      rule_groups = JSON.parse(f.read, :symbolize_names => true)
+      # Convert hash keys to integers (from something like :"9" -> 9)
+      @rule_groups = {}
+      rule_groups.each do |suffix_size, rules|
+        @rule_groups[suffix_size.to_s.to_i] = rules
       end
     end
   end
 
-  def deinflect(word)
-    possibilities = []
-    rules_less_than_size(word.size).each do |size, rules|
-      ending = word[-size..-1]
-      rules.each do |rule|
-        next  unless ending == rule[:from]
-        deinflected_word = "#{word[0..-size-1]}#{rule[:to]}"
-        next  if possibilities.include?(deinflected_word)
-        # Weight is between 0 and 1, 1 being a higher chance of actual deinflection
-        weight = (Float(size) / word.size).round(3)
-        reason = @reasons[rule[:reason_id]]
-        possibilities << {:weight => weight, :word => deinflected_word, :reason => reason}
+  def deinflect(word, iteration = 0)
+    results = Set.new
+
+    filter_rule_groups(@rule_groups, :max_suffix_size => word.size).each do |suffix_size, rules|
+      from_suffix = word[-suffix_size..-1]
+      filter_rules(rules, :from_suffix => from_suffix).each do |rule|
+        results << result_hash(word, from_suffix, rule[:to_suffix], rule[:reason])
+      end
+    end
+
+    if iteration < 2
+      additional_results = Set.new
+      results.each do |result|
+        additional_results.merge(deinflect(result[:word], iteration + 1))
       end
+      results.merge(additional_results)
     end
-    possibilities
+
+    # Sort results in descending order by weight
+    results.to_a.sort{|x, y| y[:weight] <=> x[:weight]}
   end
 
   private
 
-  def rules_less_than_size(max_size)
-    @rules.clone.keep_if{|size, rules| size < max_size}
+  def result_hash(word, from_suffix, to_suffix, reason = "")
+    # Append new suffix to the original word to get the deinflection
+    deinflected_word = "#{word[0..-from_suffix.size-1]}#{to_suffix}"
+    # Weight is between 0 and 1, 1 being a higher chance of correct deinflection
+    weight = (Float(from_suffix.size) / word.size).round(3)
+    {
+      :word => deinflected_word,
+      :weight => weight,
+      :reason => reason,
+    }
+  end
+
+  def filter_rule_groups(groups, filters = {})
+    groups.clone.delete_if do |suffix_size, rules|
+      suffix_size >= filters[:max_suffix_size]  if filters[:max_suffix_size]
+    end
+  end
+
+  def filter_rules(rules, filters = {})
+    rules.clone.delete_if.each do |rule|
+      rule[:from_suffix] != filters[:from_suffix]  if filters[:from_suffix]
+    end
   end
 end

data/lib/japanese_deinflector/version.rb

@@ -1,3 +1,3 @@
 class JapaneseDeinflector
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/japanese_deinflector_spec.rb

@@ -4,67 +4,162 @@ require 'spec_helper'
 describe JapaneseDeinflector do
   subject{ JapaneseDeinflector.new }
 
-  it "deinflects plain positive verbs" do
-    # progressive tense
-    #subject.deinflect("見ている").first[:word].should == "見る"
-    #subject.deinflect("歌っている").first[:word].should == "歌う"
-
-    # past tense
-    subject.deinflect("見た").first[:word].should == "見る"
-    subject.deinflect("歌った").first[:word].should == "歌う"
-  end
+  describe "verbs" do
+    context "in present / attibutive tense" do
 
-  it "deinflects polite positive verbs" do
-    # present tense
-    subject.deinflect("見ます").first[:word].should == "見る"
-    subject.deinflect("歌います").first[:word].should == "歌う"
+      it "does not deinflect plain positive (non-inflected) verbs" do
+        subject.deinflect("見る").should be_empty
+        subject.deinflect("歌う").should be_empty
+      end
 
-    # progressive tense
-    #subject.deinflect("見ています").first[:word].should == "見る"
-    #subject.deinflect("歌っています").first[:word].should == "歌う"
+      it "deinflects polite positive verbs" do
+        subject.deinflect("見ます").first[:word].should == "見る"
+        subject.deinflect("歌います").first[:word].should == "歌う"
+      end
 
-    # past tense
-    subject.deinflect("見ました").first[:word].should == "見る"
-    subject.deinflect("歌いました").first[:word].should == "歌う"
-  end
+      it "deinflects plain negative verbs" do
+        subject.deinflect("見ない").first[:word].should == "見る"
+        subject.deinflect("歌わない").first[:word].should == "歌う"
+      end
 
-  it "deinflects plain negative verbs" do
-    # present tense
-    subject.deinflect("見ない").first[:word].should == "見る"
-    subject.deinflect("歌わない").first[:word].should == "歌う"
+      it "deinflects polite negative formal verbs" do
+        subject.deinflect("見ません").first[:word].should == "見る"
+        subject.deinflect("歌いません").first[:word].should == "歌う"
+      end
 
-    # progressive tense
-    #subject.deinflect("見ていない").first[:word].should == "見る"
-    #subject.deinflect("歌っていない").first[:word].should == "歌う"
+    end
 
-    # past tense
-    #subject.deinflect("見なかった").first[:word].should == "見る"
-    #subject.deinflect("歌わなかった").first[:word].should == "歌う"
-  end
+    context "in progressive (ongoing) tense" do
 
-  it "deinflects polite negative formal verbs" do
-    # present tense
-    subject.deinflect("見ません").first[:word].should == "見る"
-    subject.deinflect("歌いません").first[:word].should == "歌う"
+      it "deinflects plain positive verbs" do
+        pending "unimplemented"
 
-    # progressive tense
-    #subject.deinflect("見ていません").first[:word].should == "見る"
-    #subject.deinflect("歌っていません").first[:word].should == "歌う"
+        subject.deinflect("見ている").first[:word].should == "見る"
+        subject.deinflect("歌っている").first[:word].should == "歌う"
+      end
 
-    # past tense
-    subject.deinflect("見ませんでした").first[:word].should == "見る"
-    subject.deinflect("歌いませんでした").first[:word].should == "歌う"
-  end
+      it "deinflects polite positive verbs" do
+        pending "unimplemented"
+
+        subject.deinflect("見ています").first[:word].should == "見る"
+        subject.deinflect("歌っています").first[:word].should == "歌う"
+      end
+
+      it "deinflects plain negative verbs" do
+        pending "unimplemented"
+
+        subject.deinflect("見ていない").first[:word].should == "見る"
+        subject.deinflect("歌っていない").first[:word].should == "歌う"
+      end
+
+      it "deinflects polite negative formal verbs" do
+        pending "unimplemented"
+
+        subject.deinflect("見ていません").first[:word].should == "見る"
+        subject.deinflect("歌っていません").first[:word].should == "歌う"
+      end
+
+    end
+
+    context "in past / present-perfect tense" do
+
+      it "deinflects plain positive verbs" do
+        subject.deinflect("見た").first[:word].should == "見る"
+        subject.deinflect("歌った").first[:word].should == "歌う"
+      end
+
+      it "deinflects polite positive verbs" do
+        subject.deinflect("見ました").first[:word].should == "見る"
+        subject.deinflect("歌いました").first[:word].should == "歌う"
+      end
+
+      it "deinflects plain negative verbs" do
+        subject.deinflect("見なかった").first[:word].should == "見る"
+        subject.deinflect("歌わなかった").first[:word].should == "歌う"
+      end
+
+      it "deinflects polite negative formal verbs" do
+        subject.deinflect("見ませんでした").first[:word].should == "見る"
+        subject.deinflect("歌いませんでした").first[:word].should == "歌う"
+      end
+
+    end
+
+    context "presumptive verbs" do
 
-  it "deinflects polite negative formal adjectives" do
-    # present tense
-    subject.deinflect("嬉しくありません").first[:word].should == "嬉しい"
+      it "deinflects plain verbs" do
+        subject.deinflect("見よう").first[:word].should == "見る"
+        subject.deinflect("歌おう").first[:word].should == "歌う"
+        subject.deinflect("走ろう").first[:word].should == "走る"
+      end
 
-    # past tense
-    subject.deinflect("嬉しくありませんでした").first[:word].should == "嬉しい"
+      it "deinflects polite verbs" do
+        subject.deinflect("見ましょう").first[:word].should == "見る"
+        subject.deinflect("歌いましょう").first[:word].should == "歌う"
+        subject.deinflect("走りましょう").first[:word].should == "走る"
+      end
+
+    end
+
+    context "imperative verbs" do
+
+      it "deinflects plain positive verbs" do
+        subject.deinflect("見ろ").first[:word].should == "見る"
+        subject.deinflect("歌え").first[:word].should == "歌う"
+        subject.deinflect("走れ").first[:word].should == "走る"
+      end
+
+      it "deinflects plain negative verbs" do
+        subject.deinflect("見るな").first[:word].should == "見る"
+        subject.deinflect("歌うな").first[:word].should == "歌う"
+        subject.deinflect("走るな").first[:word].should == "走る"
+      end
+
+    end
+
+    context "provisional verbs" do
+
+      it "deinflects positive verbs" do
+        subject.deinflect("見れば").first[:word].should == "見る"
+        subject.deinflect("歌えば").first[:word].should == "歌う"
+      end
+
+      it "deinflects negative verbs" do
+        subject.deinflect("見なければ").first[:word].should == "見る"
+        subject.deinflect("歌えなければ").first[:word].should == "歌う"
+      end
+
+    end
+
+    context "in conditional form" do
+
+      it "deinflects plain positive verbs" do
+        subject.deinflect("見たら").first[:word].should == "見る"
+        subject.deinflect("歌ったら").first[:word].should == "歌う"
+      end
+
+      it "deinflects plain negative verbs" do
+        pending "unimplemented"
+
+        subject.deinflect("見なかったら").first[:word].should == "見る"
+        subject.deinflect("歌わなかったら").first[:word].should == "歌う"
+      end
+
+      it "deinflects polite positive verbs" do
+        subject.deinflect("見ましたら").first[:word].should == "見る"
+        subject.deinflect("歌いましたら").first[:word].should == "歌う"
+      end
+
+    end
   end
 
-  it "deinflects imperative verbs" do
-    subject.deinflect("歌って").first[:word].should == "歌う"
+  describe "adjectives" do
+    it "deinflects adjectives in present tense" do
+      subject.deinflect("嬉しくありません").first[:word].should == "嬉しい"
+    end
+
+    it "deinflects adjectives in past tense" do
+      subject.deinflect("嬉しくありませんでした").first[:word].should == "嬉しい"
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: japanese_deinflector
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-28 00:00:00.000000000 Z
+date: 2012-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -70,6 +70,7 @@ files:
 - .rspec
 - .travis.yml
 - Gemfile
+- README.md
 - Rakefile
 - japanese_deinflector.gemspec
 - lib/data/deinflect.dat
@@ -99,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Deinflect (unconjugate/undecline) Japanese words.