flatulent 0.0.1 → 0.0.2

data/rails/lib/flatulent/text/metaphone.rb

@@ -0,0 +1,97 @@
+# 
+# An implementation of the Metaphone phonetic coding system in Ruby.
+# 
+# Metaphone encodes names into a phonetic form such that similar-sounding names
+# have the same or similar Metaphone encodings.
+# 
+# The original system was described by Lawrence Philips in Computer Language
+# Vol. 7 No. 12, December 1990, pp 39-43.
+# 
+# As there are multiple implementations of Metaphone, each with their own
+# quirks, I have based this on my interpretation of the algorithm specification.
+# Even LP's original BASIC implementation appears to contain bugs (specifically
+# with the handling of CC and MB), when compared to his explanation of the
+# algorithm.
+# 
+# I have also compared this implementation with that found in PHP's standard
+# library, which appears to mimic the behaviour of LP's original BASIC
+# implementation. For compatibility, these rules can also be used by passing
+# :buggy=>true to the methods.
+# 
+# Author: Paul Battley (pbattley@gmail.com)
+#
+
+module Text # :nodoc:
+module Metaphone
+
+  module Rules # :nodoc:all
+    
+    # Metaphone rules.  These are simply applied in order.
+    #
+    STANDARD = [ 
+      # Regexp, replacement
+      [ /([bcdfhjklmnpqrstvwxyz])\1+/,
+                         '\1' ],  # Remove doubled consonants except g.
+                                  # [PHP] remove c from regexp.
+      [ /^ae/,            'E' ],
+      [ /^[gkp]n/,        'N' ],
+      [ /^wr/,            'R' ],
+      [ /^x/,             'S' ],
+      [ /^wh/,            'W' ],
+      [ /mb$/,            'M' ],  # [PHP] remove $ from regexp.
+      [ /(?!^)sch/,      'SK' ],
+      [ /th/,             '0' ],
+      [ /t?ch|sh/,        'X' ],
+      [ /c(?=ia)/,        'X' ],
+      [ /[st](?=i[ao])/,  'X' ],
+      [ /s?c(?=[iey])/,   'S' ],
+      [ /[cq]/,           'K' ],
+      [ /dg(?=[iey])/,    'J' ],
+      [ /d/,              'T' ],
+      [ /g(?=h[^aeiou])/, ''  ],
+      [ /gn(ed)?/,        'N' ],
+      [ /([^g]|^)g(?=[iey])/,
+                        '\1J' ],
+      [ /g+/,             'K' ],
+      [ /ph/,             'F' ],
+      [ /([aeiou])h(?=\b|[^aeiou])/,
+                         '\1' ],
+      [ /[wy](?![aeiou])/, '' ],
+      [ /z/,              'S' ],
+      [ /v/,              'F' ],
+      [ /(?!^)[aeiou]+/,  ''  ],
+    ]
+  
+    # The rules for the 'buggy' alternate implementation used by PHP etc.
+    #
+    BUGGY = STANDARD.dup
+    BUGGY[0] = [ /([bdfhjklmnpqrstvwxyz])\1+/, '\1' ]
+    BUGGY[6] = [ /mb/, 'M' ]
+  end
+
+  # Returns the Metaphone representation of a string. If the string contains
+  # multiple words, each word in turn is converted into its Metaphone
+  # representation. Note that only the letters A-Z are supported, so any
+  # language-specific processing should be done beforehand.
+  #
+  # If the :buggy option is set, alternate 'buggy' rules are used.
+  #
+  def metaphone(str, options={})
+    return str.strip.split(/\s+/).map { |w| metaphone_word(w, options) }.join(' ')
+  end
+  
+private
+
+  def metaphone_word(w, options={})
+    # Normalise case and remove non-ASCII
+    s = w.downcase.gsub(/[^a-z]/, '')
+    # Apply the Metaphone rules
+    rules = options[:buggy] ? Rules::BUGGY : Rules::STANDARD
+    rules.each { |rx, rep| s.gsub!(rx, rep) }
+    return s.upcase
+  end
+
+  extend self
+
+end
+end

data/rails/lib/flatulent/text/porter_stemming.rb

@@ -0,0 +1,171 @@
+#
+# This is the Porter Stemming algorithm, ported to Ruby from the
+# version coded up in Perl.  It's easy to follow against the rules
+# in the original paper in:
+#
+#   Porter, 1980, An algorithm for suffix stripping, Program, Vol. 14,
+#   no. 3, pp 130-137,
+#
+# Taken from http://www.tartarus.org/~martin/PorterStemmer (Public Domain)
+#
+module Text # :nodoc:
+module PorterStemming
+
+  STEP_2_LIST = {
+    'ational' => 'ate', 'tional' => 'tion', 'enci' => 'ence', 'anci' => 'ance',
+    'izer' => 'ize', 'bli' => 'ble',
+    'alli' => 'al', 'entli' => 'ent', 'eli' => 'e', 'ousli' => 'ous',
+    'ization' => 'ize', 'ation' => 'ate',
+    'ator' => 'ate', 'alism' => 'al', 'iveness' => 'ive', 'fulness' => 'ful',
+    'ousness' => 'ous', 'aliti' => 'al',
+    'iviti' => 'ive', 'biliti' => 'ble', 'logi' => 'log'
+  }
+  
+  STEP_3_LIST = {
+    'icate' => 'ic', 'ative' => '', 'alize' => 'al', 'iciti' => 'ic',
+    'ical' => 'ic', 'ful' => '', 'ness' => ''
+  }
+
+  SUFFIX_1_REGEXP = /(
+                    ational  |
+                    tional   |
+                    enci     |
+                    anci     |
+                    izer     |
+                    bli      |
+                    alli     |
+                    entli    |
+                    eli      |
+                    ousli    |
+                    ization  |
+                    ation    |
+                    ator     |
+                    alism    |
+                    iveness  |
+                    fulness  |
+                    ousness  |
+                    aliti    |
+                    iviti    |
+                    biliti   |
+                    logi)$/x
+
+  SUFFIX_2_REGEXP = /(
+                      al       |
+                      ance     |
+                      ence     |
+                      er       |
+                      ic       | 
+                      able     |
+                      ible     |
+                      ant      |
+                      ement    |
+                      ment     |
+                      ent      |
+                      ou       |
+                      ism      |
+                      ate      |
+                      iti      |
+                      ous      |
+                      ive      |
+                      ize)$/x
+
+  C = "[^aeiou]"             # consonant
+  V = "[aeiouy]"             # vowel
+  CC = "#{C}(?>[^aeiouy]*)"  # consonant sequence
+  VV = "#{V}(?>[aeiou]*)"    # vowel sequence
+
+  MGR0 = /^(#{CC})?#{VV}#{CC}/o                # [cc]vvcc... is m>0
+  MEQ1 = /^(#{CC})?#{VV}#{CC}(#{VV})?$/o       # [cc]vvcc[vv] is m=1
+  MGR1 = /^(#{CC})?#{VV}#{CC}#{VV}#{CC}/o      # [cc]vvccvvcc... is m>1
+  VOWEL_IN_STEM   = /^(#{CC})?#{V}/o           # vowel in stem
+  
+  def self.stem(word)
+
+    # make a copy of the given object and convert it to a string.
+    word = word.dup.to_str
+    
+    return word if word.length < 3
+    
+    # now map initial y to Y so that the patterns never treat it as vowel
+    word[0] = 'Y' if word[0] == ?y
+    
+    # Step 1a
+    if word =~ /(ss|i)es$/
+      word = $` + $1
+    elsif word =~ /([^s])s$/ 
+      word = $` + $1
+    end
+
+    # Step 1b
+    if word =~ /eed$/
+      word.chop! if $` =~ MGR0 
+    elsif word =~ /(ed|ing)$/
+      stem = $`
+      if stem =~ VOWEL_IN_STEM 
+        word = stem
+        case word
+          when /(at|bl|iz)$/             then word << "e"
+          when /([^aeiouylsz])\1$/       then word.chop!
+          when /^#{CC}#{V}[^aeiouwxy]$/o then word << "e"
+        end
+      end
+    end
+
+    if word =~ /y$/ 
+      stem = $`
+      word = stem + "i" if stem =~ VOWEL_IN_STEM 
+    end
+
+    # Step 2
+    if word =~ SUFFIX_1_REGEXP
+      stem = $`
+      suffix = $1
+      # print "stem= " + stem + "\n" + "suffix=" + suffix + "\n"
+      if stem =~ MGR0
+        word = stem + STEP_2_LIST[suffix]
+      end
+    end
+
+    # Step 3
+    if word =~ /(icate|ative|alize|iciti|ical|ful|ness)$/
+      stem = $`
+      suffix = $1
+      if stem =~ MGR0
+        word = stem + STEP_3_LIST[suffix]
+      end
+    end
+
+    # Step 4
+    if word =~ SUFFIX_2_REGEXP
+      stem = $`
+      if stem =~ MGR1
+        word = stem
+      end
+    elsif word =~ /(s|t)(ion)$/
+      stem = $` + $1
+      if stem =~ MGR1
+        word = stem
+      end
+    end
+
+    #  Step 5
+    if word =~ /e$/ 
+      stem = $`
+      if (stem =~ MGR1) ||
+          (stem =~ MEQ1 && stem !~ /^#{CC}#{V}[^aeiouwxy]$/o)
+        word = stem
+      end
+    end
+
+    if word =~ /ll$/ && word =~ MGR1
+      word.chop!
+    end
+
+    # and turn initial Y back to y
+    word[0] = 'y' if word[0] == ?Y
+
+    word
+  end
+
+end
+end

data/rails/lib/flatulent/text/soundex.rb

@@ -0,0 +1,61 @@
+#
+# Ruby implementation of the Soundex algorithm,
+# as described by Knuth in volume 3 of The Art of Computer Programming.
+#
+# Author: Michael Neumann (neumann@s-direktnet.de)
+#
+
+module Text # :nodoc:
+module Soundex
+
+  def soundex(str_or_arr)
+    case str_or_arr
+    when String
+      soundex_str(str_or_arr)
+    when Array
+      str_or_arr.collect{|ele| soundex_str(ele)}
+    else
+      nil
+    end
+  end
+  module_function :soundex
+
+  private
+
+  #
+  # returns nil if the value couldn't be calculated (empty-string, wrong-character)
+  # do not change the parameter "str"
+  #
+  def soundex_str(str)
+    return nil if str.empty?
+
+    str = str.upcase
+    last_code = get_code(str[0,1])
+    soundex_code = str[0,1]
+
+    for index in 1...(str.size) do
+      return soundex_code if soundex_code.size == 4
+
+      code = get_code(str[index,1])
+    
+      if code == "0" then
+        last_code = nil
+      elsif code == nil then
+        return nil
+      elsif code != last_code then
+        soundex_code += code
+        last_code = code        
+      end 
+    end # for
+  
+    return soundex_code + "000"[0,4-soundex_code.size]
+  end
+  module_function :soundex_str
+          
+  def get_code(char)
+    char.tr! "AEIOUYWHBPFVCSKGJQXZDTLMNR", "00000000111122222222334556"
+  end
+  module_function :get_code
+
+end # module Soundex
+end # module Text

data/rails/lib/flatulent/text.rb

@@ -0,0 +1,6 @@
+require 'text/double_metaphone'
+require 'text/figlet'
+require 'text/levenshtein'
+require 'text/metaphone'
+require 'text/porter_stemming'
+require 'text/soundex'