japanese_names 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66e24980c69de00af005fe290cb738acadc6a42c
-  data.tar.gz: fe841d057b518bc964f19d79004892565e6d80e0
+  metadata.gz: 6da3f9dacc4174a93a90ea9bb7dd707d4a51346c
+  data.tar.gz: 164351ec8ed4957d82bef3001142b802562c10c0
 SHA512:
-  metadata.gz: e8392c49fe7e1d091889af90fd78e80b4ce41635c25a70247caf317f3697d047f85dfb17357c7b1ed53898974ad73de8e271cb2b56f76c9c4ba8a6fe75b7d304
-  data.tar.gz: 928c0867d2ccdcaaf502d1318d2e2126cb29e5f719c414fe6b40ca530bc2a39985be870b78f3a1ea7f697f8f5931575df25b23390bfb7107f53f22459dd63f8a
+  metadata.gz: 30db2c3ae0959b4012e79ea257a2dcb87a6b86964fb1934540689e7b751c36a98f3749c6334a67044f3516258e67fb984ada3be8db13d1d59837072523fd76a6
+  data.tar.gz: 493dc8d0ed918f1e213cc7bf0526ac21298ea64d4915e4fdc4a592727dbd0c577d8ddda12ce432dba25746a9d28fddb960c29688c207cebb33b784b5f5efafa8

data/README.md

@@ -39,7 +39,7 @@ Note that romaji data has been removed from our `enamdict.min` file in the compr
 
 ### Splitter#split
 
-Currently the main method is `split` which, given a kanji and kana representation of a name splits
+The main method is `split` which, given a kanji and kana representation of a name splits
 into to family/given names.
 
    ```ruby
@@ -47,36 +47,46 @@ into to family/given names.
    splitter.split('堺雅美', 'さかいマサミ')  #=> [['堺', '雅美'], ['さかい', 'マサミ']]
    ```
 
+Over a test corpus of over 22,000 names it yields a failure rate of less than 0.5%.
+
 The logic is as follows:
 
-* Step 1: Split kanji name into possible surname sub-strings
+* Step 1: Split kanji name into possible sub-strings from the middle out-ward.
 
    ```
    上原亜沙子 => 
 
-   上原亜沙子
-   上原亜沙
-   上原亜
-   上原
-   上
+   上原     亜沙子
+   上原亜     沙子
+   上     原亜沙子
+   上原亜沙     子
    ```
 
 * Step 2: Lookup possible kana matches in dictionary (done in a single pass)
 
    ```
-   上原亜沙子 => X
-   上原亜沙　 => X
-   上原亜　　 => X
    上原　　　 => かみはら　かみばら　うえはら うえばら...
+   亜沙子    => あさこ
+   上原亜　　 => X
+   亜沙　    => さこ
    上　　　　 => かみ　うえ ...
+   原亜沙子　 => X
+   ...
    ```
 
-* Step 3: Compare kana lookups versus kana name and detect first match (starting from longest candidate string)
+* Step 3: Compare kana lookups versus kana name and detect first match.
+If the kana string can be matched from both sides and yield the same result,
+we will return that result immediately. Otherwise we return the first single sided match
+found.
 
    ```
    うえはらあさこ contains かみはら ? => X
    うえはらあさこ contains かみばら ? => X
    うえはらあさこ contains うえはら ? => YES! [うえはら]あさこ
+   
+   うえはらあさこ contains あさこ ? => YES! うえはら[あさこ]
+   
+   Double-sided match found! ==> Return immediately
    ```
 
 * Step 4: If match found, split names accordingly
@@ -86,22 +96,7 @@ The logic is as follows:
    [うえはら]あさこ => うえはら あさこ
    ```
 
-* Step 5: If match not found, repeat steps 1-4 in reverse for given name:
-
-   ```
-   上原亜沙子 => 
-
-   上原亜沙子 => X
-   　原亜沙子 => X
-   　　亜沙子 => あさこ
-   　　　沙子 => さこ
-   　　　　子 => こ
-
-   上原[亜沙子]  => 上原 亜沙子
-   うえはら[あさこ] => うえはら あさこ
-   ```
-
-* Step 6: If match still not found, return `nil`
+* Step 5: If match still not found, return `nil`
 
 
 ## Rake Tasks

data/lib/japanese_names/backend/memory/store.rb

@@ -1,25 +1,41 @@
-module JapaneseNames
-module Backend
-module Memory
-  class Store
+# frozen_string_literal: true
 
-    class << self
+module JapaneseNames
+  module Backend
+    module Memory
+      # In-memory store of the Enamdict dictionary
+      class Store
+        class << self
+          # Public: Finds kanji and/or kana regex strings in the dictionary via
+          # a structured query interface.
+          #
+          # kanji - (String, Array) Value or array of values of the kanji name to match.
+          #
+          # Returns the dict entries as an Array of Arrays [[kanji, kana, flags], ...]
+          def find(kanji)
+            kanji = Array(kanji)
+            store.values_at(*kanji).reject(&:nil?).inject(&:+) || []
+          end
 
-      # Public: The memoized dictionary instance.
-      def store
-        @store ||= File.open(filepath, 'r:utf-8').map do |line|
-          line.chop.split('|').map(&:freeze).freeze
-        end.freeze
-      end
+          # Public: The memoized dictionary instance.
+          def store
+            @store ||= JapaneseNames::Util::Kernel.deep_freeze(
+              File.open(filepath, 'r:utf-8').each_with_object({}) do |line, hash|
+                ary = line.chop.split('|')
+                hash[ary[0]] ||= []
+                hash[ary[0]] << ary
+              end
+            )
+          end
 
-      private
+          private
 
-      # Internal: Returns the filepath to the enamdict.min file.
-      def filepath
-        File.join(JapaneseNames.root, 'bin/enamdict.min')
+          # Internal: Returns the filepath to the enamdict.min file.
+          def filepath
+            File.join(JapaneseNames.root, 'bin/enamdict.min')
+          end
+        end
       end
     end
   end
 end
-end
-end

data/lib/japanese_names/enamdict.rb

@@ -1,15 +1,16 @@
-module JapaneseNames
+# frozen_string_literal: true
 
+module JapaneseNames
   # Enumerated flags for the ENAMDICT file (http://www.csse.monash.edu.au/~jwb/enamdict_doc.html)
   module Enamdict
-    NAME_PLACE        = %i(p).freeze # place-name (99,500)
-    NAME_PERSON       = %i(u).freeze # person name, either given or surname, as-yet unclassified (139,000)
-    NAME_SURNAME      = %i(s).freeze # surname (138,500)
-    NAME_GIVEN_MALE   = %i(m).freeze # male given name (14,500)
-    NAME_GIVEN_FEMALE = %i(f).freeze # female given name (106,300)
-    NAME_GIVEN_OTHER  = %i(g).freeze # given name, as-yet not classified by sex (64,600)
+    NAME_PLACE        = %i[p].freeze # place-name (99,500)
+    NAME_PERSON       = %i[u].freeze # person name, either given or surname, as-yet unclassified (139,000)
+    NAME_SURNAME      = %i[s].freeze # surname (138,500)
+    NAME_GIVEN_MALE   = %i[m].freeze # male given name (14,500)
+    NAME_GIVEN_FEMALE = %i[f].freeze # female given name (106,300)
+    NAME_GIVEN_OTHER  = %i[g].freeze # given name, as-yet not classified by sex (64,600)
     NAME_SURNAME_ANY = (NAME_PLACE | NAME_PERSON | NAME_SURNAME).freeze
-    NAME_GIVEN_ANY   = (NAME_PERSON | NAME_GIVEN_MALE| NAME_GIVEN_FEMALE | NAME_GIVEN_OTHER).freeze
+    NAME_GIVEN_ANY   = (NAME_PERSON | NAME_GIVEN_MALE | NAME_GIVEN_FEMALE | NAME_GIVEN_OTHER).freeze
     NAME_ANY = (NAME_SURNAME_ANY | NAME_GIVEN_ANY).freeze
   end
 end

data/lib/japanese_names/finder.rb

@@ -1,21 +1,21 @@
-module JapaneseNames
+# frozen_string_literal: true
 
+module JapaneseNames
   # Query interface for ENAMDICT
   class Finder
-
     # Hash opts
     # - kanji: String kanji to match
     # - kana:  String kana to match
     # - kanji: Array<Symbol> ENAMDICT flags to match
-    def find(opts={})
-      backend.find(opts)
+    def find(*args)
+      backend.find(*args)
     end
 
     private
 
     # Internal: Builds regex criteria for name.
     def backend
-      ::JapaneseNames::Backend::Memory::Finder
+      ::JapaneseNames::Backend::Memory::Store
     end
   end
 end

data/lib/japanese_names/splitter.rb

@@ -1,8 +1,8 @@
-module JapaneseNames
+# frozen_string_literal: true
 
+module JapaneseNames
   # Provides methods to split a full Japanese name strings into surname and given name.
   class Splitter
-
     # Given a kanji and kana representation of a name splits into to family/given names.
     #
     # The choice to prioritize family name is arbitrary. Further analysis is needed
@@ -11,37 +11,62 @@ module JapaneseNames
     # Returns Array [[kanji_fam, kanji_giv], [kana_fam, kana_giv]] if there was a match.
     # Returns nil if there was no match.
     def split(kanji, kana)
-      split_surname(kanji, kana) || split_given(kanji, kana)
+      return nil unless kanji && kana
+      kanji = kanji.strip
+      kana  = kana.strip
+
+      # Partition kanji into candidate n-grams
+      kanji_ngrams = Util::Ngram.ngram_partition(kanji)
+
+      # Find all possible matches of all kanji n-grams in dictionary
+      dict = finder.find(kanji_ngrams.flatten.uniq)
+
+      first_lhs_match = nil
+      first_rhs_match = nil
+      kanji_ngrams.each do |kanji_pair|
+        lhs_dict = dict.select { |d| d[0] == kanji_pair[0] }
+        rhs_dict = dict.select { |d| d[0] == kanji_pair[1] }
+
+        lhs_match = detect_lhs(lhs_dict, kanji, kana)
+        rhs_match = detect_rhs(rhs_dict, kanji, kana)
+
+        return lhs_match if lhs_match && lhs_match == rhs_match
+
+        first_lhs_match ||= lhs_match
+        first_rhs_match ||= rhs_match
+      end
+
+      # As a fallback, return single-sided match prioritizing surname match first
+      first_lhs_match || first_rhs_match
     end
 
-    def split_giv(kanji, kana)
-      return nil unless kanji && kana
-      kanji, kana = kanji.strip, kana.strip
-      dict = finder.find(kanji: Util::Ngram.ngram_right(kanji))
-      dict.sort!{|x,y| y[0].size <=> x[0].size}
-      kana_match = nil
-      if match = dict.detect{|m| kana_match = kana[/#{hk m[1]}\z/]}
-        return [[Util::Ngram.mask_right(kanji, match[0]), match[0]],[Util::Ngram.mask_right(kana, kana_match), kana_match]]
+    private
+
+    def detect_lhs(dict, kanji, kana)
+      dict_match = dict.select { |d| match_kana_lhs(d, kana) }.sort_by { |m| m[1].size * -1 }.first
+      if dict_match
+        kana_match = match_kana_lhs(dict_match, kana)
+        return [[dict_match[0], Util::Ngram.mask_left(kanji, dict_match[0])],
+                [kana_match, Util::Ngram.mask_left(kana, kana_match)]]
       end
     end
-    alias :split_given :split_giv
 
-    def split_sur(kanji, kana)
-      return nil unless kanji && kana
-      kanji, kana = kanji.strip, kana.strip
-      dict = finder.find(kanji: Util::Ngram.ngram_left(kanji))
-      dict.sort!{|x,y| y[0].size <=> x[0].size}
-      kana_match = nil
-      if match = dict.detect{|m| kana_match = kana[/\A#{hk m[1]}/]}
-        return [[match[0], Util::Ngram.mask_left(kanji, match[0])],[kana_match, Util::Ngram.mask_left(kana, kana_match)]]
+    def detect_rhs(dict, kanji, kana)
+      dict_match = dict.select { |d| match_kana_rhs(d, kana) }.sort_by { |m| m[1].size * -1 }.first
+      if dict_match
+        kana_match = match_kana_rhs(dict_match, kana)
+        return [[Util::Ngram.mask_right(kanji, dict_match[0]), dict_match[0]],
+                [Util::Ngram.mask_right(kana, kana_match), kana_match]]
       end
     end
-    alias :split_surname :split_sur
 
-    # TODO: add option to strip honorific '様'
-    # TODO: add option to infer sex (0 = unknown, 1 = male, 2 = female as per ISO/IEC 5218)
+    def match_kana_lhs(dict, kana)
+      kana[/\A#{hk dict[1]}/]
+    end
 
-    private
+    def match_kana_rhs(dict, kana)
+      kana[/#{hk dict[1]}\z/]
+    end
 
     # Returns a regex string which matches both hiragana and katakana variations of a String.
     def hk(str)

data/lib/japanese_names/util/kernel.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JapaneseNames
+  module Util
+    # Provides extensions to Ruby kernel.
+    class Kernel
+      class << self
+        # Recursively freezes an object
+        def deep_freeze(object)
+          case object
+          when Hash
+            object.each_value { |v| deep_freeze(v) }
+            object.freeze
+          when Array
+            object.each { |j| deep_freeze(j) }
+            object.freeze
+          when String
+            object.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/japanese_names/util/ngram.rb

@@ -1,46 +1,49 @@
+# frozen_string_literal: true
+
 module JapaneseNames
-module Util
+  module Util
+    # Provides methods for parsing Japanese name strings.
+    class Ngram
+      class << self
+        # Generates middle-out partition n-grams for a string
+        def ngram_partition(str)
+          size = str.size
+          spiral_partition_indexes(size).map do |i|
+            index_partition(str, i)
+          end
+        end
 
-  # Provides methods for parsing Japanese name strings.
-  class Ngram
+        # Partitions a string based on an index
+        def index_partition(str, i)
+          [str[0...i], str[i..-1]]
+        end
 
-    class << self
+        # Lists middle-out partition points for a given string length
+        def spiral_partition_indexes(size)
+          ary = []
+          last = size / 2
+          ary << last
+          (size - 2).times do |i|
+            last += (i + 1) * (-1)**i
+            ary << last
+          end
+          ary
+        end
 
-      # Given a String, returns an ordered array of all possible substrings.
-      #
-      # Example: ngram_right("abcd")  #=> ["abcd", "abc", "bcd", "ab", "bc", "cd", "a", "b", "c", "d"]
-      def ngram(str)
-        (0...str.size).to_a.reverse.map{|i| (0...(str.size-i)).map{|j| str[j..(i+j)]}}.flatten.uniq
-      end
+        # Masks a String from the left side and returns the remaining (right) portion of the String.
+        #
+        # Example: mask_left("abcde", "ab") #=> "cde"
+        def mask_left(str, mask)
+          str.gsub(/\A#{mask}/, '')
+        end
 
-      # Given a String, returns an array of progressively smaller substrings anchored on the left side.
-      #
-      # Example: ngram_left("abcd")  #=> ["abcd", "abc", "ab", "a"]
-      def ngram_left(str)
-        (0...str.size).to_a.reverse.map{|i| str[0..i]}
-      end
-
-      # Given a String, returns an array of progressively smaller substrings anchored on the right side.
-      #
-      # Example: ngram_right("abcd")  #=> ["abcd", "bcd", "cd", "d"]
-      def ngram_right(str)
-        (0...str.size).map{|i| str[i..-1]}
-      end
-
-      # Masks a String from the left side and returns the remaining (right) portion of the String.
-      #
-      # Example: mask_left("abcde", "ab") #=> "cde"
-      def mask_left(str, mask)
-        str.gsub(/^#{mask}/, '')
-      end
-
-      # Masks a String from the right side and returns the remaining (left) portion of the String.
-      #
-      # Example:  mask_right("abcde", "de") #=> "abc"
-      def mask_right(str, mask)
-        str.gsub(/#{mask}$/, '')
+        # Masks a String from the right side and returns the remaining (left) portion of the String.
+        #
+        # Example:  mask_right("abcde", "de") #=> "abc"
+        def mask_right(str, mask)
+          str.gsub(/#{mask}\z/, '')
+        end
       end
     end
   end
 end
-end

data/lib/japanese_names/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JapaneseNames
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/japanese_names.rb

@@ -1,4 +1,6 @@
-$:.unshift File.dirname(__FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
 
 require 'moji'
 
@@ -6,10 +8,11 @@ require 'japanese_names/version'
 require 'japanese_names/enamdict'
 require 'japanese_names/finder'
 require 'japanese_names/splitter'
+require 'japanese_names/util/kernel'
 require 'japanese_names/util/ngram'
 require 'japanese_names/backend/memory/store'
-require 'japanese_names/backend/memory/finder'
 
+# Root namespace for library
 module JapaneseNames
   def self.root
     File.join(File.dirname(__FILE__), '../')

data/spec/config.yml

@@ -0,0 +1,422 @@
+---
+:last_names:
+  - 青木 あおき
+  - 秋保 アキホ
+  - 阿部 あべ
+  - 新井 あらい
+  - 安藤 あんどう
+  - 池田 いけだ
+  - 石井 いしい
+  - 石川 いしかわ
+  - 石田 いしだ
+  - 伊藤 イトウ
+  - 伊藤 いとう
+  - 犬山 イヌヤマ
+  - 井上 いのうえ
+  - 今井 いまい
+  - 岩崎 いわさき
+  - 上田 うえだ
+  - 上野 うえの
+  - 上原 ウエハラ
+  - 内田 うちだ
+  - 遠藤 えんどう
+  - 太田 おおた
+  - 大塚 おおつか
+  - 大野 おおの
+  - 岡田 オカダ
+  - 岡田 おかだ
+  - 岡本 おかもと
+  - 小川 おがわ
+  - 小野 おの
+  - 加藤 かとう
+  - 金子 かねこ
+  - 河野 かわの
+  - 菊池 きくち
+  - 木村 きむら
+  - 工藤 くどう
+  - 熊澤 クマザワ
+  - 小島 こじま
+  - 後藤 ごとう
+  - 小早志 コバヤシ
+  - 小林 こばやし
+  - 小山 こやま
+  - 近藤 こんどう
+  - 斎藤 さいとう
+  - 斉藤 さいとう
+  - 堺 サカイ
+  - 酒井 さかい
+  - 堺 さかい
+  - 坂本 さかもと
+  - 桜井 さくらい
+  - 佐々木 ささき
+  - 佐藤 サトウ
+  - 佐藤 さとう
+  - 佐野 さの
+  - 柴田 しばた
+  - 島田 しまだ
+  - 清水 しみず
+  - 菅原 すがわら
+  - 杉山 すぎやま
+  - 鈴木 すずき
+  - 高木 たかぎ
+  - 高田 たかだ
+  - 高野 たかの
+  - 高橋 たかはし
+  - 竹内 たけうち
+  - 武田 たけだ
+  - 田中 タナカ
+  - 田中 たなか
+  - 谷口 たにぐち
+  - 田村 たむら
+  - 千葉 ちば
+  - 中川 なかがわ
+  - 中島 なかじま
+  - 中野 なかの
+  - 中村 ナカムラ
+  - 中村 なかむら
+  - 中山 なかやま
+  - 西村 にしむら
+  - 野口 のぐち
+  - 野村 のむら
+  - 橋本 はしもと
+  - 長谷川 はせがわ
+  - 濱田 ハマダ
+  - 林 はやし
+  - 原 はら
+  - 原田 はらだ
+  - 樋口 ヒグチ
+  - 平野 ひらの
+  - 福田 ふくだ
+  - 藤井 ふじい
+  - 藤田 ふじた
+  - 藤原 ふじわら
+  - 古川 ふるかわ
+  - 前田 まえだ
+  - 増田 ますだ
+  - 松井 まつい
+  - 松田 まつだ
+  - 松本 まつもと
+  - 丸山 まるやま
+  - 三浦 みうら
+  - 光野 ミツノ
+  - 宮崎 みやざき
+  - 宮本 みやもと
+  - 村上 むらかみ
+  - 村田 むらた
+  - 森 モリ
+  - 森 もり
+  - 森田 もりた
+  - 安田 ヤスダ
+  - 山口 やまぐち
+  - 山崎 やまさき
+  - 山崎 ヤマザキ
+  - 山下 やました
+  - 山田 やまだ
+  - 山本 やまもと
+  - 横山 よこやま
+  - 吉田 よしだ
+  - 和田 わだ
+  - 渡辺 わたなべ
+  - 渡部 わたなべ
+
+:first_names:
+  - 愛 あい
+  - 愛子 あいこ
+  - 愛美 あいみ
+  - 愛莉 あいり
+  - 愛理 あいり
+  - 愛梨 あいり
+  - 葵 あおい
+  - 昭夫 あきお
+  - 明 あきら
+  - 明美 あけみ
+  - 亜佐子 アサコ
+  - 朝陽 あさひ
+  - 杏那 あな
+  - 雨夜 あまや
+  - 彩花 あやか
+  - 彩乃 あやの
+  - 彩美 あやみ
+  - 郁子 イクコ
+  - 郁子 いくこ
+  - 勇 いさむ
+  - 樹 いつき
+  - 梅子 うめこ
+  - 瑛太 えいた
+  - 愛美 えみ
+  - 恵美 えみ
+  - 恵里 エリ
+  - 修 おさむ
+  - 海斗 かいと
+  - 香 かおり
+  - 一樹 かずき
+  - 和子 かずこ
+  - 香澄 カスミ
+  - 霞 かすみ
+  - 和美 かずみ
+  - 和也 かずや
+  - 克己 かつみ
+  - 寛 かん
+  - 清 きよし
+  - 桐子 きりこ
+  - 久美子 くみこ
+  - 敬子 ケイコ
+  - 慶子 けいこ
+  - 恵介 けいすけ
+  - 健三 けんぞう
+  - 健太 けんた
+  - 剛 ごう
+  - 康平 こうへい
+  - 虎太郎 こたろう
+  - 心春 こはる
+  - 咲希 さき
+  - 咲良 さくら
+  - 桜 さくら
+  - サクラ さくら
+  - 貞子 さだこ
+  - 禎子 さだこ
+  - 幸子 サチコ
+  - 幸子 さちこ
+  - 皐 さつき
+  - 三郎 さぶろ
+  - 小夜 さや
+  - 小百合 さゆり
+  - 重子 しげこ
+  - 茂 しげる
+  - 静香 しずか
+  - 駿 しゅん
+  - 翔 しょう
+  - 翔太 しょうた
+  - 四郎 しろ
+  - 真 しん
+  - 真一 しんいち
+  - 進 すすむ
+  - 節子 せつこ
+  - 颯太 そうた
+  - 颯真 そうま
+  - 蒼空 そら
+  - 大雅 たいが
+  - 大輝 たいき
+  - 大樹 だいき
+  - 大輝 だいき
+  - 大輔 だいすけ
+  - 大地 だいち
+  - 貴子 タカコ
+  - 孝 たかし
+  - 匠 たくみ
+  - 拓也 たくや
+  - 丈夫 たけお
+  - 武 たけし
+  - 武 たける
+  - 正 ただし
+  - 千夏 ちなつ
+  - 千代 ちよ
+  - 千代子 ちよこ
+  - 翼 つばさ
+  - 剛 つよし
+  - 貞子 ていこ
+  - 徹男 テツオ
+  - 哲也 てつや
+  - 智子 ともこ
+  - 知美 トモミ
+  - 朋美 ともみ
+  - 知美 ともみ
+  - 直樹 なおき
+  - 直子 なおこ
+  - 直美 なおみ
+  - 夏希 なつき
+  - 七海 ななみ
+  - 望 ノゾミ
+  - 延 のぶ
+  - 法子 のりこ
+  - 華 はな
+  - 隼人 はやと
+  - 遥 はるか
+  - 大翔 はると
+  - 陽翔 はると
+  - 陽斗 はると
+  - 悠人 はると
+  - 春菜 はるな
+  - 悠真 はるま
+  - 瞳 ひとみ
+  - 陽菜 ひな
+  - 陽向 ひなた
+  - 陽太 ひなた
+  - 陽葵 ひまり
+  - 大樹 ひろき
+  - 弘子 ひろこ
+  - 寛 ひろし
+  - 大翔 ひろと
+  - 文子 ふみこ
+  - 紅子 べにこ
+  - 螢 ほたる
+  - 舞 まい
+  - 誠 まこと
+  - 真 まこと
+  - 正男 まさお
+  - 正博 まさひろ
+  - 雅美 マサミ
+  - 勝 まさる
+  - 愛菜 まな
+  - 学 まなぶ
+  - 愛美 マナミ
+  - 真美 まみ
+  - 真弓 まゆみ
+  - 美羽 みう
+  - 美咲 みさき
+  - 美智 ミチ
+  - 緑 みどり
+  - 美菜 みな
+  - 湊 みなと
+  - 実 みのる
+  - 美優 みゆ
+  - 心優 みゆ
+  - 芽生 めい
+  - 芽依 めい
+  - めぐみ メグミ
+  - 恵 めぐみ
+  - 萌 もえ
+  - 桃子 ももこ
+  - 大和 やまと
+  - 結愛 ゆあ
+  - 結衣 ゆい
+  - 優香 ゆうか
+  - 優太 ゆうた
+  - 雄大 ゆうだい
+  - 悠斗 ゆうと
+  - 優斗 ゆうと
+  - 悠人 ゆうと
+  - 優奈 ゆうな
+  - 結菜 ゆうな
+  - 悠真 ゆうま
+  - 之子 ユキコ
+  - 雪子 ゆきこ
+  - 豊 ゆたか
+  - 優月 ゆづき
+  - 結菜 ゆな
+  - 由美 ゆみ
+  - 由美子 ゆみこ
+  - 百合子 ゆりこ
+  - 洋子 ヨウコ
+  - 陽子 ようこ
+  - 陽太 ようた
+  - 陽子 よこ
+  - 義雄 よしお
+  - 良子 よしこ
+  - 陸 りく
+  - 莉子 りこ
+  - 龍之介 りゅうのすけ
+  - 涼 りょう
+  - 凛 りん
+  - 麗華 れいか
+  - 玲子 レイコ
+  - 蓮 れん
+
+:skip:
+  - 青木 緑
+  - 石井 真
+  - 石井 延
+  - 石川 舞
+  - 石川 緑
+  - 石川 湊
+  - 今井 真
+  - 今井 延
+  - 上野 愛
+  - 上野 真
+  - 太田 舞
+  - 太田 湊
+  - 岡本 萌
+  - 小野 愛
+  - 小野 真
+  - 金子 萌
+  - 河野 愛
+  - 河野 真
+  - 小山 咲希
+  - 小山 真
+  - 小山 緑
+  - 小山 陸
+  - 近藤 康平
+  - 近藤 虎太郎
+  - 近藤 心春
+  - 酒井 真
+  - 酒井 延
+  - 坂本 萌
+  - 桜井 真
+  - 桜井 延
+  - 佐々木 杏那
+  - 佐々木 三郎
+  - 佐々木 四郎
+  - 佐々木 緑
+  - 佐々木 陽子
+  - 佐々木 莉子
+  - 佐野 愛
+  - 佐野 真
+  - 柴田 舞
+  - 柴田 湊
+  - 杉山 真
+  - 杉山 緑
+  - 杉山 陸
+  - 鈴木 緑
+  - 高野 愛
+  - 高野 真
+  - 竹内 匠
+  - 田中 延
+  - 田中 緑
+  - 田中 湊
+  - 中野 愛
+  - 中野 真
+  - 中山 真
+  - 中山 緑
+  - 中山 陸
+  - 橋本 萌
+  - 長谷川 杏那
+  - 長谷川 三郎
+  - 長谷川 四郎
+  - 長谷川 陽子
+  - 林 咲希
+  - 林 孝
+  - 原 咲希
+  - 原 延
+  - 原 法子
+  - 平野 愛
+  - 平野 真
+  - 藤井 真
+  - 藤井 延
+  - 藤田 舞
+  - 藤田 湊
+  - 藤原 延
+  - 藤原 法子
+  - 古川 舞
+  - 古川 緑
+  - 古川 湊
+  - 松井 真
+  - 松井 延
+  - 松本 萌
+  - 丸山 真
+  - 丸山 緑
+  - 丸山 陸
+  - 宮本 萌
+  - 村田 舞
+  - 村田 湊
+  - 森 亜佐子
+  - 森 貴子
+  - 森 克己
+  - 森 久美子
+  - 森 咲希
+  - 森 孝
+  - 森田 舞
+  - 森田 湊
+  - 山本 萌
+  - 横山 真
+  - 横山 緑
+  - 横山 陸
+  - 和田 咲希
+  - 和田 重子
+  - 和田 茂
+  - 和田 静香
+  - 和田 駿
+  - 和田 翔
+  - 和田 翔太
+  - 和田 四郎
+  - 和田 真
+  - 和田 真一

data/spec/spec_helper.rb

@@ -1,9 +1,14 @@
-$:.push File.expand_path('../../lib', __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
 
 require 'rubygems'
 require 'rspec'
+require 'yaml'
 require 'japanese_names'
 
 RSpec.configure do |config|
   config.mock_with :rspec
+
+  config.disable_monkey_patching!
 end

data/spec/unit/finder_spec.rb

@@ -1,39 +1,14 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe JapaneseNames::Finder do
+require 'spec_helper'
 
+RSpec.describe JapaneseNames::Finder do
   subject { described_class.new }
 
   describe '#find' do
-
     it 'should match kanji only' do
-      result = subject.find(kanji: '外世子')
-      result.should eq [["外世子", "とよこ", "f"]]
-    end
-
-    it 'should match kana only' do
-      result = subject.find(kana: 'ならしま')
-      result.should eq [["樽島", "ならしま", "u"],
-                        ["奈良島", "ならしま", "s"],
-                        ["楢島", "ならしま", "s"],
-                        ["楢嶋", "ならしま", "s"]]
-    end
-
-    it 'should match both kanji and kana only' do
-      result = subject.find(kanji: '楢二郎', kana: 'ならじろう')
-      result.should eq [["楢二郎", "ならじろう", "m"]]
-    end
-
-    it 'should match flags as String' do
-      result = subject.find(kana: 'ならしま', flags: 's')
-      result.should eq [["奈良島", "ならしま", "s"],
-                        ["楢島", "ならしま", "s"],
-                        ["楢嶋", "ならしま", "s"]]
-    end
-
-    it 'should match flags as Array' do
-      result = subject.find(kana: 'ならしま', flags: ['u','g'])
-      result.should eq [["樽島", "ならしま", "u"]]
+      result = subject.find('外世子')
+      expect(result).to eq [%w[外世子 とよこ f]]
     end
   end
 end

data/spec/unit/ngram_spec.rb

@@ -1,24 +1,35 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe JapaneseNames::Util::Ngram do
+require 'spec_helper'
 
-  describe '#ngram' do
-    it { expect(described_class.ngram("abcd")).to eq ["abcd", "abc", "bcd", "ab", "bc", "cd", "a", "b", "c", "d"] }
+RSpec.describe JapaneseNames::Util::Ngram do
+  describe '#ngram_partition' do
+    it { expect(described_class.ngram_partition('abcd')).to eq [%w[ab cd], %w[abc d], %w[a bcd]] }
+    it { expect(described_class.ngram_partition('abcde')).to eq [%w[ab cde], %w[abc de], %w[a bcde], %w[abcd e]] }
   end
 
-  describe '#ngram_left' do
-    it { expect(described_class.ngram_left("abcd")).to eq ["abcd", "abc", "ab", "a"] }
+  describe '#index_partition' do
+    it { expect(described_class.index_partition('abcde', 2)).to eq %w[ab cde] }
   end
 
-  describe '#ngram_right' do
-    it { expect(described_class.ngram_right("abcd")).to eq ["abcd", "bcd", "cd", "d"] }
+  describe '#spiral_partition_indexes' do
+    it { expect(described_class.spiral_partition_indexes(0)).to eq [0] }
+    it { expect(described_class.spiral_partition_indexes(1)).to eq [0] }
+    it { expect(described_class.spiral_partition_indexes(2)).to eq [1] }
+    it { expect(described_class.spiral_partition_indexes(3)).to eq [1, 2] }
+    it { expect(described_class.spiral_partition_indexes(4)).to eq [2, 3, 1] }
+    it { expect(described_class.spiral_partition_indexes(5)).to eq [2, 3, 1, 4] }
+    it { expect(described_class.spiral_partition_indexes(6)).to eq [3, 4, 2, 5, 1] }
+    it { expect(described_class.spiral_partition_indexes(7)).to eq [3, 4, 2, 5, 1, 6] }
+    it { expect(described_class.spiral_partition_indexes(8)).to eq [4, 5, 3, 6, 2, 7, 1] }
+    it { expect(described_class.spiral_partition_indexes(9)).to eq [4, 5, 3, 6, 2, 7, 1, 8] }
   end
 
   describe '#mask_left' do
-    it { expect(described_class.mask_left("abcde", "ab")).to eq "cde" }
+    it { expect(described_class.mask_left('abcde', 'ab')).to eq 'cde' }
   end
 
   describe '#mask_right' do
-    it { expect(described_class.mask_right("abcde", "de")).to eq "abc" }
+    it { expect(described_class.mask_right('abcde', 'de')).to eq 'abc' }
   end
 end

data/spec/unit/splitter_spec.rb

@@ -1,50 +1,42 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe JapaneseNames::Splitter do
+require 'spec_helper'
 
+RSpec.describe JapaneseNames::Splitter do
   subject { described_class.new }
 
   describe '#split' do
+    config = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'config.yml'))
+    skip_list = config[:skip]
 
-    [['上原','望','ウエハラ','ノゾミ'],
-     ['樋口','知美','ヒグチ','ともみ'],
-     ['堺','雅美','さかい','マサミ'],
-     ['中村','幸子','ナカムラ','サチコ'],
-     ['秋保','郁子','アキホ','いくこ'],
-     ['光野','亜佐子','ミツノ','アサコ'],
-     ['熊澤','貴子','クマザワ','タカコ']].each do |kanji_fam, kanji_giv, kana_fam, kana_giv|
-      it "should parse #{kanji_fam+kanji_giv} #{kana_fam+kana_giv}" do
-        result = subject.split(kanji_fam+kanji_giv, kana_fam+kana_giv)
-        result.should eq [[kanji_fam, kanji_giv], [kana_fam, kana_giv]]
-      end
+    config[:last_names].each do |last_name|
+      config[:first_names].each do |first_name|
+        kanji_fam, kana_fam = last_name.split(' ')
+        kanji_giv, kana_giv = first_name.split(' ')
 
-      it "should parse #{kanji_fam+kanji_giv} #{kana_fam+kana_giv} by given name" do
-        result = subject.split_giv(kanji_fam+kanji_giv, kana_fam+kana_giv)
-        result.should eq [[kanji_fam, kanji_giv], [kana_fam, kana_giv]]
-      end
+        next if skip_list.index("#{kanji_fam} #{kanji_giv}")
 
-      it "should parse #{kanji_fam+kanji_giv} #{kana_fam+kana_giv} by family name" do
-        result = subject.split_sur(kanji_fam+kanji_giv, kana_fam+kana_giv)
-        result.should eq [[kanji_fam, kanji_giv], [kana_fam, kana_giv]]
+        it "should parse #{kanji_fam + kanji_giv} #{kana_fam + kana_giv}" do
+          result = subject.split(kanji_fam + kanji_giv, kana_fam + kana_giv)
+          expect(result).to eq [[kanji_fam, kanji_giv], [kana_fam, kana_giv]]
+        end
       end
     end
 
-    [['XXX','XXX','XXX','XXX']].each do |kanji_fam, kanji_giv, kana_fam, kana_giv|
-      it "should return nil for invalid name #{kanji_fam+kanji_giv} #{kana_fam+kana_giv}" do
-        result = subject.split(kanji_fam+kanji_giv, kana_fam+kana_giv)
-        result.should be_nil
+    [%w[XXX XXX XXX XXX]].each do |kanji_fam, kanji_giv, kana_fam, kana_giv|
+      it "should return nil for invalid name #{kanji_fam + kanji_giv} #{kana_fam + kana_giv}" do
+        result = subject.split(kanji_fam + kanji_giv, kana_fam + kana_giv)
+        expect(result).to eq nil
       end
     end
 
     it 'should strip leading/trailing whitespace' do
-      subject.split(' 上原望 ', ' ウエハラノゾミ ').should eq [['上原','望'],['ウエハラ','ノゾミ']]
-      subject.split_giv(' 上原望 ', ' ウエハラノゾミ ').should eq [['上原','望'],['ウエハラ','ノゾミ']]
-      subject.split_sur(' 上原望 ', ' ウエハラノゾミ ').should eq [['上原','望'],['ウエハラ','ノゾミ']]
+      expect(subject.split(' 上原望 ', ' ウエハラノゾミ ')).to eq [%w[上原 望], %w[ウエハラ ノゾミ]]
     end
 
     it 'should return nil for nil input' do
-      subject.split(nil, 'ウエハラノゾミ').should be_nil
-      subject.split('上原望', nil).should be_nil
+      expect(subject.split(nil, 'ウエハラノゾミ')).to eq nil
+      expect(subject.split('上原望', nil)).to eq nil
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: japanese_names
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Johnny Shields
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2017-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: moji
@@ -76,13 +76,14 @@ files:
 - README.md
 - bin/enamdict.min
 - lib/japanese_names.rb
-- lib/japanese_names/backend/memory/finder.rb
 - lib/japanese_names/backend/memory/store.rb
 - lib/japanese_names/enamdict.rb
 - lib/japanese_names/finder.rb
 - lib/japanese_names/splitter.rb
+- lib/japanese_names/util/kernel.rb
 - lib/japanese_names/util/ngram.rb
 - lib/japanese_names/version.rb
+- spec/config.yml
 - spec/spec_helper.rb
 - spec/unit/finder_spec.rb
 - spec/unit/ngram_spec.rb
@@ -107,11 +108,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Tools for parsing japanese names
 test_files:
+- spec/config.yml
 - spec/spec_helper.rb
 - spec/unit/finder_spec.rb
 - spec/unit/ngram_spec.rb

data/lib/japanese_names/backend/memory/finder.rb

@@ -1,55 +0,0 @@
-module JapaneseNames
-module Backend
-module Memory
-  class Finder
-
-    class << self
-
-      # Public: Finds kanji and/or kana regex strings in the dictionary via
-      # a structured query interface.
-      #
-      # opts - The Hash options used to match the dictionary (default: {}):
-      #        kanji: Regex to match kanji name (optional)
-      #        kana:  Regex to match kana name (optional)
-      #        flags: Flag or Array of flags to filter the match (optional)
-      #
-      # Returns the dict entries as an Array of Arrays [[kanji, kana, flags], ...]
-      def find(opts={})
-        return [] unless opts[:kanji] || opts[:kana]
-        kanji = name_regex  opts.delete(:kanji)
-        kana  = name_regex  opts.delete(:kana)
-        flags = flags_regex opts.delete(:flags)
-        store.select do |row|
-          (!kanji || row[0] =~ kanji) && (!kana || row[1] =~ kana) && (!flags || row[2] =~ flags)
-        end
-      end
-
-      private
-
-      def store
-        ::JapaneseNames::Backend::Memory::Store.store
-      end
-
-      # Internal: Builds regex criteria for name.
-      def name_regex(name)
-        case name
-          when String, Symbol then /\A#{name}\z/
-          when Array then /\A(?:#{name.join('|')})\z/
-          else nil
-        end
-      end
-
-      # Internal: Builds regex criteria for flags.
-      def flags_regex(flags)
-        case flags
-          when ::JapaneseNames::Enamdict::NAME_ANY then nil
-          when String, Symbol then /[#{flags}]/
-          when Array then /[#{flags.join}]/
-          else nil
-        end
-      end
-    end
-  end
-end
-end
-end