phonetic 1.0.0

data/lib/phonetic/metaphone.rb

@@ -0,0 +1,161 @@
+require 'phonetic/algorithm'
+
+module Phonetic
+  # Metaphone is a phonetic algorithm, published by Lawrence Philips in 1990,
+  # for indexing words by their English pronunciation.
+  # This class implements this algorithm.
+  # @see http://aspell.net/metaphone/metaphone.basic Original Basic code by Lawrence Philips (1990)
+  # @example
+  #    Phonetic::Metaphone.encode('Accola') # => 'AKKL'
+  #    Phonetic::Metaphone.encode('Nikki') # => 'NK'
+  #    Phonetic::Metaphone.encode('Wright') #=> 'RT'
+  class Metaphone < Algorithm
+    VOWELS = 'AEIOU'
+    FRONT_VOWELS = 'EIY'
+    VARSON = 'CSPTG'
+
+    # Encode word to its Metaphone code
+    def self.encode_word(word, options = { size: 4 })
+      code_size = options[:size] || 4
+      w = word.upcase.gsub(/[^A-Z]/, '')
+      return if w.empty?
+      two = w[0, 2]
+      if ['PN', 'AE', 'KN', 'GN', 'WR'].include?(two) then w[0] = '' end
+      if w[0] == 'X' then w[0] = 'S' end
+      if two == 'WH' then w[1] = '' end
+      l = w.size
+      metaph = ''
+      for n in 0..(l - 1)
+        break unless metaph.size < code_size
+        symb = w[n]
+        if !(symb != 'C' && n > 0 && w[n - 1] == symb)
+          case
+          when vowel?(symb) && n == 0
+            metaph = symb
+          when symb == 'B'
+            unless n == l - 1 && w[n - 1] == 'M'
+              metaph = metaph + symb
+            end
+          when symb == 'C'
+            if !(n > 0 && w[n - 1] == 'S' && front_vowel?(w[n + 1]))
+              if w[n + 1, 2] == 'IA'
+                metaph = metaph + 'X'
+              else
+                if front_vowel?(w[n + 1])
+                  metaph = metaph + 'S'
+                else
+                  if n > 0 && w[n + 1] == 'H' && w[n - 1] == 'S'
+                    metaph = metaph + 'K'
+                  else
+                    if w[n + 1] == 'H'
+                      if n == 0 && !vowel?(w[n + 2])
+                        metaph = metaph + 'K'
+                      else
+                        metaph = metaph + 'X'
+                      end
+                    else
+                      metaph = metaph + 'K'
+                    end
+                  end
+                end
+              end
+            end
+          when symb == 'D'
+            if w[n + 1] == 'G' && front_vowel?(w[n + 2])
+              metaph = metaph + 'J'
+            else
+              metaph = metaph + 'T'
+            end
+          when symb == 'G'
+            silent = (w[n + 1] == 'H' && !vowel?(w[n + 2]))
+            if n > 0 && (w[n + 1] == 'N' || w[n + 1, 3] == 'NED')
+              silent = true
+            end
+            if n > 0 && w[n - 1] == 'D' && front_vowel?(w[n + 1])
+              silent = true
+            end
+            hard = (n > 0 && w[n - 1] == 'G')
+            unless silent
+              if front_vowel?(w[n + 1]) && !hard
+                metaph = metaph + 'J'
+              else
+                metaph = metaph + 'K'
+              end
+            end
+          when symb == 'H'
+            if !(n == l - 1 || (n > 0 && VARSON[w[n - 1]]))
+              if vowel?(w[n + 1])
+                metaph = metaph + 'H'
+              end
+            end
+          when 'FJLMNR'[symb]
+            metaph = metaph + symb
+          when symb == 'K'
+            if n > 0 && w[n - 1] != 'C'
+              metaph = metaph + 'K'
+            else
+              if n == 0
+                metaph = 'K'
+              end
+            end
+          when symb == 'P'
+            if w[n + 1] == 'H'
+              metaph = metaph + 'F'
+            else
+              metaph = metaph + 'P'
+            end
+          when symb == 'Q'
+            metaph = metaph + 'K'
+          when symb == 'S'
+            if w[n + 1] == 'I' && (w[n + 2] == 'O' || w[n + 2] == 'A')
+              metaph += 'X'
+            else
+              if w[n + 1] == 'H'
+                metaph += 'X'
+              else
+                metaph += 'S'
+              end
+            end
+          when symb == 'T'
+            if w[n + 1] == 'I' && (w[n + 2] == 'O' || w[n + 2] == 'A')
+              metaph = metaph + 'X'
+            else
+              if w[n + 1] == 'H'
+                if !(n > 0 && w[n - 1] == 'T')
+                  metaph = metaph + '0'
+                end
+              else
+                if !(w[n + 1] == 'C' && w[n + 2] == 'H')
+                  metaph = metaph + 'T'
+                end
+              end
+            end
+          when symb == 'V'
+            metaph = metaph + 'F'
+          when symb == 'W' || symb == 'Y'
+            if vowel?(w[n + 1])
+              metaph = metaph + symb
+            end
+          when symb == 'X'
+            metaph = metaph + 'KS'
+          when symb == 'Z'
+            metaph = metaph + 'S'
+          end
+        end
+      end
+      metaph
+    end
+
+    private
+
+    def self.vowel?(symbol)
+      v = VOWELS[symbol.to_s]
+      !v.nil? && !v.empty?
+    end
+
+    def self.front_vowel?(symbol)
+      v = FRONT_VOWELS[symbol.to_s]
+      !v.nil? && !v.empty?
+    end
+  end
+end

data/lib/phonetic/metaphone2.rb

@@ -0,0 +1,5 @@
+require 'phonetic/double_metaphone'
+
+module Phonetic
+  Metaphone2 = DoubleMetaphone
+end

data/lib/phonetic/nysiis.rb

@@ -0,0 +1,63 @@
+require 'phonetic/algorithm'
+
+module Phonetic
+  # This class implements original version of NYSIIS algorithm.
+  # @example
+  #    Phonetic::NYSIIS.encode('Alexandra') # => 'ALAXANDR'
+  #    Phonetic::NYSIIS.encode('Aumont') # => 'AANAD'
+  #    Phonetic::NYSIIS.encode('Bonnie') # => 'BANY'
+  class NYSIIS < Algorithm
+    FIRST_CHAR_TABLE = {
+      /^MAC/ => 'MCC',
+      /^KN/ => 'NN',
+      /^K/ => 'C',
+      /^(PH|PF)/ => 'FF',
+      /^SCH/ => 'SSS'
+    }
+
+    LAST_CHAR_TABLE = {
+      /(EE|IE)$/ => 'Y',
+      /(DT|RT|RD|NT|ND)$/ => 'D'
+    }
+
+    REMAINING_TABLE = {
+      'EV' => 'AF',
+      /[AEIOU]+/ => 'A',
+      'Q' => 'G',
+      'Z' => 'S',
+      'M' => 'N',
+      'KN' => 'N',
+      'K' => 'C',
+      'SCH' => 'SSS',
+      'PH' => 'FF',
+      /([^AEIOU])H/ => '\1',
+      /(.)H[^AEIOU]/ => '\1',
+      /[AEIOU]W/ => 'A'
+    }
+
+    LAST_TABLE = {
+      /S$/ => '',
+      /AY$/ => 'Y',
+      /A$/ => ''
+    }
+
+    # Convert word to its NYSIIS code
+    def self.encode_word(word, options = { trim: true })
+      return if !word or word.empty?
+      trim = options[:trim]
+      w = word.upcase
+      w.gsub!(/[^A-Z]/, '')
+      return if w.empty?
+      FIRST_CHAR_TABLE.each{ |rx, str| break if w.sub!(rx, str) }
+      LAST_CHAR_TABLE.each{ |rx, str| w.sub!(rx, str) }
+      first = w[0]
+      w = w[1...w.size].to_s
+      REMAINING_TABLE.each{ |rx, str| w.gsub!(rx, str) }
+      LAST_TABLE.each{ |rx, str| w.gsub!(rx, str) }
+      w.gsub!(/[^\w\s]|(.)(?=\1)/, '') # remove duplicates
+      w = first + w
+      w = w[0..5] if trim
+      w
+    end
+  end
+end

data/lib/phonetic/refined_soundex.rb

@@ -0,0 +1,39 @@
+require 'phonetic/algorithm'
+
+module Phonetic
+  # Class for encoding string to Refined Soundex code.
+  # A refined soundex code is optimized for spell checking words.
+  #
+  # @example
+  #    Phonetic::RefinedSoundex.encode('Caren')   # => 'C30908'
+  #    Phonetic::RefinedSoundex.encode('Hayers')  # => 'H093'
+  #    Phonetic::RefinedSoundex.encode('Lambard') # => 'L7081096'
+  class RefinedSoundex < Algorithm
+    CODE = {
+      B: 1, P: 1,
+      F: 2, V: 2,
+      C: 3, K: 3, S: 3,
+      G: 4, J: 4,
+      Q: 5, X: 5, Z: 5,
+      D: 6, T: 6,
+      L: 7,
+      M: 8, N: 8,
+      R: 9
+    }
+
+    # Encode word to its Refined Soundex value
+    def self.encode_word(word, options = {})
+      w = word.upcase
+      res = w[0]
+      pg = nil
+      w.chars.each do |c|
+        g = CODE[c.to_sym] || 0
+        if pg != g
+          res += g.to_s
+          pg = g
+        end
+      end
+      res
+    end
+  end
+end

data/lib/phonetic/soundex.rb

@@ -0,0 +1,39 @@
+require 'phonetic/algorithm'
+
+module Phonetic
+  # Soundex phonetic algorithm was developed by Robert C. Russell and Margaret K. Odell.
+  # This class implements American Soundex version of algorithm.
+  #
+  # @example
+  #    Phonetic::Soundex.encode('Ackerman') # => 'A265'
+  #    Phonetic::Soundex.encode('ammonium') # => 'A500'
+  #    Phonetic::Soundex.encode('implementation') # => 'I514'
+  class Soundex < Algorithm
+    CODE = {
+      B: 1, P: 1, F: 1, V: 1,
+      C: 2, S: 2, K: 2, G: 2, J: 2, Q: 2, X: 2, Z: 2,
+      D: 3, T: 3,
+      L: 4,
+      M: 5, N: 5,
+      R: 6
+    }
+
+    # Convert word to its Soundex code
+    def self.encode_word(word, options = {})
+      return '' if word.empty?
+      w = word.upcase
+      res = w[0]
+      pg = CODE[w[0].to_sym]
+      (1...w.size).each do |i|
+        g = CODE[w[i].to_sym]
+        if g and pg != g
+          res += g.to_s
+          pg = g
+        end
+        break if res.size > 3
+      end
+      res = res.ljust(4, '0')
+      res
+    end
+  end
+end

data/lib/phonetic/version.rb

@@ -0,0 +1,3 @@
+module Phonetic
+  VERSION = '1.0.0'
+end

data/phonetic.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'phonetic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'phonetic'
+  spec.version       = Phonetic::VERSION
+  spec.authors       = ['n7v']
+  spec.email         = ['novsem@gmail.com']
+  spec.description   = %q{Ruby library for phonetic algorithms.}
+  spec.summary       = %q{Ruby library for phonetic algorithms. It supports Soundex, Metaphone, Caverphone, NYSIIS and others}
+  spec.homepage      = 'http://github.com/n7v/phonetic'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'yard'
+end

data/spec/phonetic/algorithm_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Phonetic::Algorithm do
+  describe '.encode_word' do
+    it 'should return not modified word' do
+      Phonetic::Algorithm.encode_word('cat').should == 'cat'
+    end
+  end
+
+  describe '.encode' do
+    it 'should return list of words without extra spaces' do
+      Phonetic::Algorithm.encode('  cat  dog  ').should == 'cat dog'
+    end
+  end
+end

data/spec/phonetic/caverphone2_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+# Examples are taken from Caversham Project's paper
+# http://caversham.otago.ac.nz/files/working/ctp150804.pdf
+CAVERPHONE2_TEST_TABLE = {
+  'STFNSN1111' => ['Stevenson'],
+  'PTA1111111' => ['Peter'],
+  'AT11111111' => [
+    'add', 'aid', 'at', 'art', 'eat', 'earth', 'head', 'hit', 'hot',
+    'hold', 'hard', 'heart', 'it', 'out', 'old'
+  ],
+  'RTA1111111' => ['rather', 'ready', 'writer'],
+  'SSA1111111' => ['social'],
+  'APA1111111' => ['able', 'appear'],
+  'TTA1111111' => [
+    'Darda', 'Datha', 'Dedie', 'Deedee', 'Deerdre', 'Deidre', 'Deirdre',
+    'Detta', 'Didi', 'Didier', 'Dido', 'Dierdre', 'Dieter', 'Dita',
+    'Ditter', 'Dodi', 'Dodie', 'Dody', 'Doherty', 'Dorthea', 'Dorthy',
+    'Doti', 'Dotti', 'Dottie', 'Dotty', 'Doty', 'Doughty', 'Douty',
+    'Dowdell', 'Duthie', 'Tada', 'Taddeo', 'Tadeo', 'Tadio', 'Tati',
+    'Teador', 'Tedda', 'Tedder', 'Teddi', 'Teddie', 'Teddy', 'Tedi',
+    'Tedie', 'Teeter', 'Teodoor', 'Teodor', 'Terti', 'Theda', 'Theodor',
+    'Theodore', 'Theta', 'Thilda', 'Thordia', 'Tilda', 'Tildi', 'Tildie',
+    'Tildy', 'Tita', 'Tito', 'Tjader', 'Toddie', 'Toddy', 'Torto', 'Tuddor',
+    'Tudor', 'Turtle', 'Tuttle', 'Tutto'
+  ],
+  'KLN1111111' => [
+    'Cailean', 'Calan', 'Calen', 'Callahan', 'Callan', 'Callean',
+    'Carleen', 'Carlen', 'Carlene', 'Carlin', 'Carline', 'Carlyn',
+    'Carlynn', 'Carlynne', 'Charlean', 'Charleen', 'Charlene',
+    'Charline', 'Cherlyn', 'Chirlin', 'Clein', 'Cleon', 'Cline',
+    'Cohleen', 'Colan', 'Coleen', 'Colene', 'Colin', 'Colleen',
+    'Collen', 'Collin', 'Colline', 'Colon', 'Cullan', 'Cullen',
+    'Cullin', 'Gaelan', 'Galan', 'Galen', 'Garlan', 'Garlen',
+    'Gaulin', 'Gayleen', 'Gaylene', 'Giliane', 'Gillan', 'Gillian',
+    'Glen', 'Glenn', 'Glyn', 'Glynn', 'Gollin', 'Gorlin', 'Kalin',
+    'Karlan', 'Karleen', 'Karlen', 'Karlene', 'Karlin', 'Karlyn',
+    'Kaylyn', 'Keelin', 'Kellen', 'Kellene', 'Kellyann', 'Kellyn',
+    'Khalin', 'Kilan', 'Kilian', 'Killen', 'Killian', 'Killion',
+    'Klein', 'Kleon', 'Kline', 'Koerlin', 'Kylen', 'Kylynn', 'Quillan',
+    'Quillon', 'Qulllon', 'Xylon'
+  ],
+  'TN11111111' => [
+    'Dan', 'Dane', 'Dann', 'Darn', 'Daune', 'Dawn', 'Ddene', 'Dean', 'Deane',
+    'Deanne', 'DeeAnn', 'Deeann', 'Deeanne', 'Deeyn', 'Den', 'Dene', 'Denn',
+    'Deonne', 'Diahann', 'Dian', 'Diane', 'Diann', 'Dianne', 'Diannne', 'Dine',
+    'Dion', 'Dione', 'Dionne', 'Doane', 'Doehne', 'Don', 'Donn', 'Doone', 'Dorn',
+    'Down', 'Downe', 'Duane', 'Dun', 'Dunn', 'Duyne', 'Dyan', 'Dyane', 'Dyann',
+    'Dyanne', 'Dyun', 'Tan', 'Tann', 'Teahan', 'Ten', 'Tenn', 'Terhune', 'Thain',
+    'Thaine', 'Thane', 'Thanh', 'Thayne', 'Theone', 'Thin', 'Thorn', 'Thorne',
+    'Thun', 'Thynne', 'Tien', 'Tine', 'Tjon', 'Town', 'Towne', 'Turne', 'Tyne'
+  ]
+}
+
+describe Phonetic::Caverphone2 do
+  describe '.encode' do
+    it 'should return Caverphone 2 value of string' do
+      CAVERPHONE2_TEST_TABLE.each do |code, words|
+        words.each do |word|
+          res = Phonetic::Caverphone2.encode(word)
+          res.should eq(code), "expected: #{code}\ngot: #{res}\nword: #{word}"
+        end
+      end
+    end
+  end
+end

data/spec/phonetic/caverphone_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+CAVERPHONE_TEST_TABLE = {
+  'Addis' => 'ATS111',
+  'Alcantara' => 'AKNTR1',
+  'Allegra' => 'ALKR11',
+  'Allende' => 'ALNT11',
+  'America' => 'AMRK11',
+  'Andera' => 'ANTR11',
+  'Annamarie' => 'ANMR11',
+  'Anya' => 'ANY111',
+  'Ariane' => 'ARN111',
+  'Arnoldo' => 'ANT111',
+  'Beltran' => 'PTRN11',
+  'Blanch' => 'PLNK11',
+  'Blose' => 'PLS111',
+  'Bodie' => 'PT1111',
+  'Celentano' => 'SLNTN1',
+  'Celestine' => 'SLSTN1',
+  'Charmain' => 'KMN111',
+  'Chelsea' => 'KS1111',
+  'Coleman' => 'KLMN11',
+  'Collis' => 'KLS111',
+  'Crysta' => 'KRST11',
+  'Culwell' => 'KW1111',
+  'Dilworth' => 'TWT111',
+  'Dinkins' => 'TNKNS1',
+  'Donetta' => 'TNT111',
+  'Dreama' => 'TRM111',
+  'Dulce' => 'TS1111',
+  'Eastwood' => 'ASTWT1',
+  'Eddy' => 'AT1111',
+  'Ellett' => 'ALT111',
+  'Fazekas' => 'FSKS11',
+  'Francesco' => 'FRNSSK',
+  'Gary' => 'KR1111',
+  'Genoveva' => 'KNFF11',
+  'Gossman' => 'KSMN11',
+  'Goudy' => 'KT1111',
+  'Greta' => 'KRT111',
+  'Gunn' => 'KN1111',
+  'Hackman' => 'AKMN11',
+  'Hassie' => 'AS1111',
+  'Henrietta' => 'ANRT11',
+  'Hollaway' => 'ALW111',
+  'Hulbert' => 'APT111',
+  'Isaacson' => 'ASKSN1',
+  'Ishibashi' => 'ASPS11',
+  'Isreal' => 'ASR111',
+  'Jerez' => 'YRS111',
+  'Joette' => 'YT1111',
+  'Jonathon' => 'YNTN11',
+  'Karin' => 'KRN111',
+  'Kenneth' => 'KNT111',
+  'Koontz' => 'KNTS11',
+  'Korey' => 'KR1111',
+  'Krystle' => 'KRSTL1',
+  'Landey' => 'LNT111',
+  'Lashaunda' => 'LSNT11',
+  'Legere' => 'LKR111',
+  'Lela' => 'LL1111',
+  'Louis' => 'LS1111',
+  'Lovely' => 'LFL111',
+  'Lozano' => 'LSN111',
+  'Margo' => 'MK1111',
+  'Maricle' => 'MRKL11',
+  'Mario' => 'MR1111',
+  'Mccormick' => 'MKMK11',
+  'Melody' => 'MLT111',
+  'Mike' => 'MK1111',
+  'Milagros' => 'MLKRS1',
+  'Modesto' => 'MTST11',
+  'Mor' => 'M11111',
+  'Muse' => 'MS1111',
+  'Neil' => 'N11111',
+  'Nicolas' => 'NKLS11',
+  'Olney' => 'AN1111',
+  'Pannell' => 'PN1111',
+  'Posada' => 'PST111',
+  'Raeann' => 'RN1111',
+  'Rameau' => 'RM1111',
+  'Regal' => 'RK1111',
+  'Renetta' => 'RNT111',
+  'Sachiko' => 'SKK111',
+  'Samira' => 'SMR111',
+  'Sammie' => 'SM1111',
+  'Sara' => 'SR1111',
+  'Searcy' => 'SS1111',
+  'Seeley' => 'SL1111',
+  'Shannon' => 'SNN111',
+  'Siegmund' => 'SKMNT1',
+  'Silvera' => 'SFR111',
+  'Sitz' => 'STS111',
+  'Smyth' => 'SMT111',
+  'Steedley' => 'STTL11',
+  'Teri' => 'TR1111',
+  'Tourville' => 'TFL111',
+  'Ute' => 'AT1111',
+  'Vernon' => 'FNN111',
+  'Vidaurri' => 'FTR111',
+  'Wolff' => 'WF1111',
+  'Zeck' => 'SK1111',
+  'Zirkind' => 'SKNT11'
+}
+
+describe Phonetic::Caverphone do
+  describe '.encode' do
+    it 'should return Caverphone value of string' do
+      CAVERPHONE_TEST_TABLE.each do |word, code|
+        res = Phonetic::Caverphone.encode(word)
+        res.should eq(code), "expected: #{code}\ngot: #{res}\nword: #{word}"
+      end
+    end
+  end
+end