japanese_names 0.0.3 → 0.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YTZhOWUxMzRlNTE5ZmVmZTJkMWJmMzlhZTYzMzBjNzAxZjEzMzQ2MA==
-  data.tar.gz: !binary |-
-    MDdhYjQ3NTA3NTgxZjMyY2Q4ZmQxZTk2MzgwMmRjYzMwMzAxNmQ4Mg==
+SHA1:
+  metadata.gz: 66e24980c69de00af005fe290cb738acadc6a42c
+  data.tar.gz: fe841d057b518bc964f19d79004892565e6d80e0
 SHA512:
-  metadata.gz: !binary |-
-    ZGQxNjI5ODEyYjUwZTYzY2JlZDZmOWQwYzI4ZjRkNzc3ZTljMTc0YzdlNWNj
-    NjFiOTQ3MGJkYjg1Y2NiNTI5YWI1NTJmNWIwNWNkYTkyODU3ODU3Yjc4MDY3
-    N2Q2NmJlMGUzZWY2N2MzZjA1N2VjYTUwYTc2MDVjMTE3YWM0YWE=
-  data.tar.gz: !binary |-
-    YjRiNTMzNzQzMDc1OGQ2NWY3YmExM2VjOWMyOWE4ODBiZTFmNGQzMmI3MTJi
-    NzU0NmJiNzdhY2YwMjY5OGRiYWUzYTM4NmM2MDUwMjA3NTE0MTljY2Y2ODgx
-    ZGM2MTc1ZmVhN2ZjMTk0ZGFmZGVhOTljNTY1ZWQ1NTZiZDhlODE=
+  metadata.gz: e8392c49fe7e1d091889af90fd78e80b4ce41635c25a70247caf317f3697d047f85dfb17357c7b1ed53898974ad73de8e271cb2b56f76c9c4ba8a6fe75b7d304
+  data.tar.gz: 928c0867d2ccdcaaf502d1318d2e2126cb29e5f719c414fe6b40ca530bc2a39985be870b78f3a1ea7f697f8f5931575df25b23390bfb7107f53f22459dd63f8a

data/README.md

@@ -1,28 +1,28 @@
 # JapaneseNames
 
-JapaneseNames provides an interface to the [ENAMDIC file](http://www.csse.monash.edu.au/~jwb/enamdict_doc.html).
+JapaneseNames provides an interface to the [T file](http://www.csse.monash.edu.au/~jwb/enamdict_doc.html).
 
 
-## JapaneseNames::Enamdict
+## ENAMDICT
 
-This library comes packaged with a compacted version of the [ENAMDIC file](http://www.csse.monash.edu.au/~jwb/enamdict_doc.html)
+This library comes packaged with a compacted version of the [ENAMDICT file](http://www.csse.monash.edu.au/~jwb/enamdict_doc.html)
 at `bin/enamdict.min`. Refer to *Rake Tasks* below for how this file is constructed.
 
-`JapaneseNames::Enamdict` is a module; all methods are called on the module `self` class.
 
-
-### Enamdict.find
+### Finder.find
 
 Provides a structured query interface to access ENAMDICT data.
 
    ```ruby
-   JapaneseNames::Enamdict.find(kanji: '外世子')  #=> [["外世子", "とよこ", "f"]]
+   finder = JapaneseNames::Finder.new
+   
+   finder.find(kanji: '外世子')  #=> [["外世子", "とよこ", "f"]]
 
-   JapaneseNames::Enamdict.find(kana: 'ならしま', flags: 's')  #=> [["奈良島", "ならしま", "s"],
-                                                                      ["楢島", "ならしま", "s"],
-                                                                      ["楢嶋", "ならしま", "s"]]
+   finder.find(kana: 'ならしま', flags: 's')  #=> [["奈良島", "ならしま", "s"],
+                                            #    ["楢島", "ならしま", "s"],
+                                            #    ["楢嶋", "ならしま", "s"]]
 
-   JapaneseNames::Enamdict.find(kanji: '楢二郎', kana: 'ならじろう')  #=> [["楢二郎", "ならじろう", "m"]]
+   finder.find(kanji: '楢二郎', kana: 'ならじろう')  #=> [["楢二郎", "ならじろう", "m"]]
    ```
 
 where options are:
@@ -30,37 +30,22 @@ where options are:
 * `kanji`: The kanji name string to match. Regex syntax suppported. Either `:kanji` or `:kana` must be specified.
 * `kana`:  The kana name string to match. Regex syntax suppported.
 * `flags`: The flag char or array of flag chars to match. Refer to [ENAMDIC documentation](http://www.csse.monash.edu.au/~jwb/enamdict_doc.html).
-Additionally constants JapaneseNames::Enamdict::NAME_FAM and JapaneseNames::Enamdict::NAME_GIV may be used.
+Additionally constants `JapaneseNames::Enamdict::NAME_SURNAME` and `JapaneseNames::Enamdict::NAME_GIVEN` may be used.
 
 Note that romaji data has been removed from our `enamdict.min` file in the compression step. We recommend to use a gem such as `mojinizer` to convert romaji to kana before doing a query.
 
 
-### Enamdict.match
-
-Provides a raw interface to match ENAMDICT entries via a block, which would typically contain a `Regexp` expression:
+## JapaneseNames::Splitter
 
-   ```ruby
-   JapaneseNames::Enamdict.match{|entry| entry =~ /^堺|/}  #=> [["堺", "さかい", "p,s"], ["堺", "さかえ", "p"]]
-   ```
-
-where each dictionary entry is in the format below (different from raw ENAMDICT file):
-
-   ```
-   kanji|kana|flag1(,flag2,...)
-   ```
-
-
-## JapaneseNames::Parser
-
-### Parser#split
+### Splitter#split
 
 Currently the main method is `split` which, given a kanji and kana representation of a name splits
 into to family/given names.
 
-```ruby
-  parser = JapaneseNames::Parser.new
-  parser.split('堺雅美', 'さかいマサミ')  #=> [['堺', '雅美'], ['さかい', 'マサミ']]
-```
+   ```ruby
+   splitter = JapaneseNames::Splitter.new
+   splitter.split('堺雅美', 'さかいマサミ')  #=> [['堺', '雅美'], ['さかい', 'マサミ']]
+   ```
 
 The logic is as follows:
 

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

@@ -0,0 +1,55 @@
+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

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

@@ -0,0 +1,25 @@
+module JapaneseNames
+module Backend
+module Memory
+  class Store
+
+    class << self
+
+      # 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
+
+      private
+
+      # Internal: Returns the filepath to the enamdict.min file.
+      def filepath
+        File.join(JapaneseNames.root, 'bin/enamdict.min')
+      end
+    end
+  end
+end
+end
+end

data/lib/japanese_names/enamdict.rb

@@ -1,105 +1,15 @@
-#!/bin/env ruby
-# encoding: utf-8
-
 module JapaneseNames
 
-  # Query interface for the ENAMDICT file (http://www.csse.monash.edu.au/~jwb/enamdict_doc.html)
+  # Enumerated flags for the ENAMDICT file (http://www.csse.monash.edu.au/~jwb/enamdict_doc.html)
   module Enamdict
-
-    # s - surname (138,500)
-    # p - place-name (99,500)
-    # u - person name, either given or surname, as-yet unclassified (139,000)
-    # g - given name, as-yet not classified by sex (64,600)
-    # f - female given name (106,300)
-    # m - male given name (14,500)
-    NAME_FAM = %w(s p u)
-    NAME_GIV = %w(u g f m)
-    NAME_ANY = NAME_FAM | NAME_GIV
-
-    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)
-        regex = /^#{kanji}\|#{kana}\|#{flags}$/
-
-        match{|line| line[regex]}
-      end
-
-      # Public: Matches entries in the enamdict based on a block which should
-      # evaluate true or false (typically a regex).
-      #
-      # Returns the dict entries as an Array of Arrays [[kanji, kana, flags], ...]
-      def match(&block)
-        sel = []
-        each_line do |line|
-          if block.call(line)
-            sel << unpack_line(line)
-          end
-        end
-        sel
-      end
-
-      protected
-
-      # Internal: Returns the filepath to the enamdict.min file.
-      def filepath
-        File.join(File.dirname(__FILE__), '../../bin/enamdict.min')
-      end
-
-      # Internal: The memoized dictionary instance.
-      def dict
-        return @dict if @dict
-        @dict = []
-        File.open(self.filepath, 'r:utf-8') do |f|
-          while(line = f.gets) != nil
-            @dict << line[0..-2] # omit trailing newline char
-          end
-        end
-        @dict.freeze
-      end
-
-      # Internal: Calls the given block for each line in the dict.
-      def each_line(&block)
-        dict.each{|line| block.call(line) }
-      end
-
-      # Internal: Formats a line as a 3-tuple Array [kanji, kana, flags]
-      def unpack_line(line)
-        line.split('|')
-      end
-
-      # Internal: Builds regex criteria for name.
-      def name_regex(name)
-        case name
-          when String then name
-          when Array  then "(?:#{name.join('|')})"
-          else '.+?'
-        end
-      end
-
-      # Internal: Builds regex criteria for flags.
-      def flags_regex(flags)
-        if !flags || flags == NAME_ANY
-          '.+?'
-        elsif flags.is_a?(Array)
-          ".*?[#{flags.join}].*?"
-        else
-          flags
-        end
-      end
-    end
+    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_ANY = (NAME_SURNAME_ANY | NAME_GIVEN_ANY).freeze
   end
 end

data/lib/japanese_names/finder.rb

@@ -0,0 +1,21 @@
+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)
+    end
+
+    private
+
+    # Internal: Builds regex criteria for name.
+    def backend
+      ::JapaneseNames::Backend::Memory::Finder
+    end
+  end
+end

data/lib/japanese_names/splitter.rb

@@ -0,0 +1,55 @@
+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
+    # for whether given or family name should be prioritized.
+    #
+    # 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)
+    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]]
+      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)]]
+      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)
+
+    private
+
+    # Returns a regex string which matches both hiragana and katakana variations of a String.
+    def hk(str)
+      "(?:#{Moji.kata_to_hira(str)}|#{Moji.hira_to_kata(str)})"
+    end
+
+    def finder
+      @finder ||= Finder.new
+    end
+  end
+end

data/lib/japanese_names/util/ngram.rb

@@ -0,0 +1,46 @@
+module JapaneseNames
+module Util
+
+  # Provides methods for parsing Japanese name strings.
+  class Ngram
+
+    class << self
+
+      # 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
+
+      # 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}$/, '')
+      end
+    end
+  end
+end
+end

data/lib/japanese_names/version.rb

@@ -1,6 +1,3 @@
-#!/bin/env ruby
-# encoding: utf-8
-
 module JapaneseNames
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

data/lib/japanese_names.rb

@@ -4,4 +4,14 @@ require 'moji'
 
 require 'japanese_names/version'
 require 'japanese_names/enamdict'
-require 'japanese_names/parser'
+require 'japanese_names/finder'
+require 'japanese_names/splitter'
+require 'japanese_names/util/ngram'
+require 'japanese_names/backend/memory/store'
+require 'japanese_names/backend/memory/finder'
+
+module JapaneseNames
+  def self.root
+    File.join(File.dirname(__FILE__), '../')
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,7 @@
-#!/bin/env ruby
-# encoding: utf-8
-
 $:.push File.expand_path('../../lib', __FILE__)
 
 require 'rubygems'
+require 'rspec'
 require 'japanese_names'
 
 RSpec.configure do |config|

data/spec/unit/{enamdict_spec.rb → finder_spec.rb}

@@ -1,28 +1,8 @@
-#!/bin/env ruby
-# encoding: utf-8
-
 require 'spec_helper'
 
-describe JapaneseNames::Enamdict do
-
-  subject { JapaneseNames::Enamdict }
+describe JapaneseNames::Finder do
 
-  describe '#match' do
-
-    it 'should select only lines which match criteria' do
-      result = subject.match{|line| line =~ /^.+?\|あわのはら\|.+?$/}
-      result.should eq [["粟野原", "あわのはら", "s"]]
-    end
-
-    it 'should select multiple lines' do
-      result = subject.match{|line| line =~ /^.+?\|はしの\|.+?$/}
-      result.should eq [["橋之", "はしの", "p"],
-                        ["橋埜", "はしの", "s"],
-                        ["橋野", "はしの", "s"],
-                        ["端野", "はしの", "s"],
-                        ["箸野", "はしの", "s"]]
-    end
-  end
+  subject { described_class.new }
 
   describe '#find' do
 

data/spec/unit/ngram_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe JapaneseNames::Util::Ngram do
+
+  describe '#ngram' do
+    it { expect(described_class.ngram("abcd")).to eq ["abcd", "abc", "bcd", "ab", "bc", "cd", "a", "b", "c", "d"] }
+  end
+
+  describe '#ngram_left' do
+    it { expect(described_class.ngram_left("abcd")).to eq ["abcd", "abc", "ab", "a"] }
+  end
+
+  describe '#ngram_right' do
+    it { expect(described_class.ngram_right("abcd")).to eq ["abcd", "bcd", "cd", "d"] }
+  end
+
+  describe '#mask_left' do
+    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" }
+  end
+end

data/spec/unit/{parser_spec.rb → splitter_spec.rb}

@@ -1,21 +1,18 @@
-#!/bin/env ruby
-# encoding: utf-8
-
 require 'spec_helper'
 
-describe JapaneseNames::Parser do
+describe JapaneseNames::Splitter do
 
-  subject { JapaneseNames::Parser.new }
+  subject { described_class.new }
 
   describe '#split' do
 
-    [['上原','望','ウエハラ', 'ノゾミ'],
-     ['樋口','知美','ヒグチ', 'ともみ'],
-     ['堺','雅美','さかい', 'マサミ'],
-     ['中村','幸子','ナカムラ', 'サチコ'],
-     ['秋保','郁子','アキホ', 'いくこ'],
-     ['光野','亜佐子','ミツノ', 'アサコ'],
-     ['熊澤','貴子','クマザワ', 'タカコ']].each do |kanji_fam, kanji_giv, kana_fam, kana_giv|
+    [['上原','望','ウエハラ','ノゾミ'],
+     ['樋口','知美','ヒグチ','ともみ'],
+     ['堺','雅美','さかい','マサミ'],
+     ['中村','幸子','ナカムラ','サチコ'],
+     ['秋保','郁子','アキホ','いくこ'],
+     ['光野','亜佐子','ミツノ','アサコ'],
+     ['熊澤','貴子','クマザワ','タカコ']].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]]
@@ -27,7 +24,7 @@ describe JapaneseNames::Parser do
       end
 
       it "should parse #{kanji_fam+kanji_giv} #{kana_fam+kana_giv} by family name" do
-        result = subject.split_fam(kanji_fam+kanji_giv, kana_fam+kana_giv)
+        result = subject.split_sur(kanji_fam+kanji_giv, kana_fam+kana_giv)
         result.should eq [[kanji_fam, kanji_giv], [kana_fam, kana_giv]]
       end
     end
@@ -42,7 +39,7 @@ describe JapaneseNames::Parser do
     it 'should strip leading/trailing whitespace' do
       subject.split(' 上原望 ', ' ウエハラノゾミ ').should eq [['上原','望'],['ウエハラ','ノゾミ']]
       subject.split_giv(' 上原望 ', ' ウエハラノゾミ ').should eq [['上原','望'],['ウエハラ','ノゾミ']]
-      subject.split_fam(' 上原望 ', ' ウエハラノゾミ ').should eq [['上原','望'],['ウエハラ','ノゾミ']]
+      subject.split_sur(' 上原望 ', ' ウエハラノゾミ ').should eq [['上原','望'],['ウエハラ','ノゾミ']]
     end
 
     it 'should return nil for nil input' do

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: japanese_names
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Johnny Shields
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-08 00:00:00.000000000 Z
+date: 2016-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: moji
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.6'
 - !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: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: gem-release
   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: Japanese name parser based on ENAMDICT
@@ -76,12 +76,17 @@ 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/parser.rb
+- lib/japanese_names/finder.rb
+- lib/japanese_names/splitter.rb
+- lib/japanese_names/util/ngram.rb
 - lib/japanese_names/version.rb
 - spec/spec_helper.rb
-- spec/unit/enamdict_spec.rb
-- spec/unit/parser_spec.rb
+- spec/unit/finder_spec.rb
+- spec/unit/ngram_spec.rb
+- spec/unit/splitter_spec.rb
 homepage: https://github.com/johnnyshields/japanese_names
 licenses:
 - MIT
@@ -92,22 +97,22 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Tools for parsing japanese names
 test_files:
 - spec/spec_helper.rb
-- spec/unit/enamdict_spec.rb
-- spec/unit/parser_spec.rb
-has_rdoc: 
+- spec/unit/finder_spec.rb
+- spec/unit/ngram_spec.rb
+- spec/unit/splitter_spec.rb

data/lib/japanese_names/parser.rb

@@ -1,80 +0,0 @@
-#!/bin/env ruby
-# encoding: utf-8
-
-module JapaneseNames
-
-  # Provides methods for parsing Japanese name strings.
-  class Parser
-
-    # 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
-    # for whether given or family name should be prioritized.
-    #
-    # 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_fam(kanji, kana) || split_giv(kanji, kana)
-    end
-
-    def split_giv(kanji, kana)
-      return nil unless kanji && kana
-      kanji, kana = kanji.strip, kana.strip
-      dict = Enamdict.find(kanji: window_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]}$/]}
-        return [[mask_right(kanji, match[0]), match[0]],[mask_right(kana, kana_match), kana_match]]
-      end
-    end
-
-    def split_fam(kanji, kana)
-      return nil unless kanji && kana
-      kanji, kana = kanji.strip, kana.strip
-      dict = Enamdict.find(kanji: window_left(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]}/]}
-        return [[match[0], mask_left(kanji, match[0])],[kana_match, mask_left(kana, kana_match)]]
-      end
-    end
-
-    # TODO: add option to strip honorific '様'
-    # TODO: add option to infer sex (0 = unknown, 1 = male, 2 = female as per ISO/IEC 5218)
-
-    protected
-
-    # Returns a regex string which matches both hiragana and katakana variations of a String.
-    def hk(str)
-      "(?:#{Moji.kata_to_hira(str)}|#{Moji.hira_to_kata(str)})"
-    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}$/, '')
-    end
-
-    # Given a String, returns an array of progressively smaller substrings anchored on the left side.
-    #
-    # Example: window_left("abcd")  #=> ["abcd", "abc", "ab", "a"]
-    def window_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: window_right("abcd")  #=> ["abcd", "bcd", "cd", "d"]
-    def window_right(str)
-      (0...str.size).map{|i| str[i..-1]}
-    end
-  end
-end