mack-facets 0.8.1 → 0.8.2

data/lib/gems/english-0.3.1/lib/english/metaphone.rb

@@ -0,0 +1,110 @@
+# = title:
+#   Metaphone
+#
+# = synopsis:
+#   An implementation of the Metaphone phonetic coding system in Ruby.
+#
+# = author:
+#   Paul Battley (pbattley@gmail.com)
+
+module English # :nodoc:
+
+  #   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
+  #   :alternate=>true to the methods.
+
+  module Metaphone
+
+    extend self
+
+    # Metaphone rules.  These are simply applied in order.
+
+    RULES = [
+      # 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.
+
+    LP_RULES = RULES.dup
+    LP_RULES[0] = [ /([bdfhjklmnpqrstvwxyz])\1+/, '\1' ]
+    LP_RULES[6] = [ /mb/, 'M' ]
+
+    # 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 +alt+ is set to true, alternate 'buggy' rules are used.
+
+    def metaphone(str, alt=nil)
+      return str.strip.split(/\s+/).map{ |w| metaphone_word(w, alt) }.join(' ')
+    end
+
+  private
+
+    def metaphone_word(w, alt=nil)
+      # Normalise case and remove non-ASCII
+      s = w.downcase.gsub(/[^a-z]/, '')
+      # Apply the Metaphone rules
+      rules = alt ? LP_RULES : RULES
+      rules.each { |rx, rep| s.gsub!(rx, rep) }
+      return s.upcase
+    end
+
+  end
+
+end
+
+
+class String #:nodoc:
+
+  # Returns the Metaphone representation of a string.
+
+  def metaphone
+    English::Metaphone.metaphone(self)
+  end
+
+end

data/lib/gems/english-0.3.1/lib/english/numerals.rb

@@ -0,0 +1,71 @@
+# TITLE
+#
+#   English Numerals
+#
+# SUMMARY:
+#
+#   Convert integers into english word form.
+#
+# AUTHORS:
+#
+#   Glenn P. Parker
+
+module English #:nodoc:
+
+module Numerals
+
+  Ones = %w[ zero one two three four five six seven eight nine ]
+  Teen = %w[ ten eleven twelve thirteen fourteen fifteen
+            sixteen seventeen eighteen nineteen ]
+  Tens = %w[ zero ten twenty thirty forty fifty
+            sixty seventy eighty ninety ]
+  Mega = %w[ none thousand million billion ]
+
+  # Convert an integer to the english spelling of that number.
+
+  def name(integer)
+    places = integer.to_i.to_s.split(//).collect{|s| s.to_i}.reverse
+    name = []
+    ((places.length + 2) / 3).times do |p|
+      strings = Numerals.trio(places[p * 3, 3])
+      name.push(Mega[p]) if strings.length > 0 and p > 0
+      name += strings
+    end
+    name.push(Ones[0]) unless name.length > 0
+    name.reverse.join(" ")
+  end
+
+  private
+
+  def self.trio(places)
+    strings = []
+    if places[1] == 1
+      strings.push(Teen[places[0]])
+    elsif places[1] and places[1] > 0
+      strings.push(places[0] == 0 ? Tens[places[1]] :
+                  "#{Tens[places[1]]}-#{Ones[places[0]]}")
+    elsif places[0] > 0
+      strings.push(Ones[places[0]])
+    end
+    if places[2] and places[2] > 0
+      strings.push("hundred", Ones[places[2]])
+    end
+    strings
+  end
+
+end
+
+end # module English
+
+#
+
+class Integer #:nodoc:
+
+  #
+  #   10.english #=> 'ten'
+
+  def english
+    English::Numerals.name(self)
+  end
+
+end

data/lib/gems/english-0.3.1/lib/english/patterns.rb

@@ -0,0 +1,49 @@
+module English
+
+  # = Patterns Function Module
+  #
+  # Returns a Regexp pattern based on the given
+  # pattern string or symbolic name.
+  #
+  # They are also recognizied in plural form.
+
+  module Patterns
+
+    module_function
+
+    # Character
+
+    def char
+      //
+    end
+
+    alias_method :chars, :char
+    alias_method :character, :char
+    alias_method :characters, :char
+
+    # Word
+
+    def word
+      /\s+|\Z/
+    end
+
+    alias_method :words, :word
+
+    # Line
+
+    def line
+      /\Z/
+    end
+
+    alias_method :lines, :line
+
+    # Sentence  FIXME
+
+    def sentence
+      /[.]\ /
+    end
+
+  end
+
+end
+

data/lib/gems/english-0.3.1/lib/english/porter_stemming.rb

@@ -0,0 +1,188 @@
+# = title:
+#   Porter Stemming
+#
+# = synopsis:
+#   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)
+#
+# = author:
+#   ?
+
+module English # :nodoc:
+
+# 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 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/lib/gems/english-0.3.1/lib/english/roman.rb

@@ -0,0 +1,174 @@
+# = TITLE:
+#   Roman Numerals
+#
+# = SYNOPSIS:
+#   Generates roman numerals from integers and vice-versa.
+#
+# = NOTES:
+#   A response to Ruby Quiz of the Week #22 - Roman Numerals [ruby-talk:132925]
+#
+# = AUTHORS:
+#   - Dave Burt <dave at burt.id.au>
+#   - Trans
+
+module English #:nodoc:
+
+# Contains methods to convert integers to roman numeral strings and vice-versa.
+
+module RomanNumerals
+
+  # The largest integer representable as a roman
+  # numerable by this module.
+
+  MAX = 3999
+
+  # Stolen from O'Reilly's Perl Cookbook 6.23. Regular Expression Grabbag.
+
+  REGEXP = /^M*(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$/i
+
+  #
+
+  SYMBOLS = [  "M", "D", "C", "L", "X", "V", "I" ]
+  NUMBERS = [ 1000, 500, 100,  50,  10,   5,   1 ]
+
+
+  # Maps roman numeral digits to their integer values.
+  #   {
+  #     'I' => 1,
+  #     'V' => 5,
+  #     'X' => 10,
+  #     'L' => 50,
+  #     'C' => 100,
+  #     'D' => 500,
+  #     'M' => 1000,
+  #   }
+
+  TABLE = Hash[*SYMBOLS.zip(NUMBERS).flatten]
+
+  #
+
+  PAIR_SYMBOLS = [ "CM", "CD", "XC", "XL", "IX", "IV", "I" ]
+  PAIR_NUMBERS = [ 900,  400,    90,   40,    9,    4,   1 ]
+
+  #   {
+  #     'CM' => 900,
+  #     'CD' => 400,
+  #     'XC' => 90,
+  #     'XL' => 40,
+  #     'IX' => 9,
+  #     'IV' => 4
+  #   }
+
+  PAIR_TABLE  = Hash[*PAIR_SYMBOLS.zip(PAIR_NUMBERS).flatten]
+
+  #
+
+  LOOKUP = TABLE.invert.merge(PAIR_TABLE.invert)
+
+
+  class << self
+
+  # Converts +integer+ to a roman numeral.
+
+  def from_integer(integer)
+    return nil if integer < 0 || integer > MAX
+
+    r = integer  # remainder
+    y = ''       # result
+
+    NUMBERS.each do |n|
+      while r >= n
+        r -= n
+        y += LOOKUP[n]
+      end
+      break if r <= 0
+    end
+
+    return y
+  end
+
+  alias_method :roman, :from_integer
+
+  # Converts +roman_string+, a roman numeral, to an integer
+
+  def to_integer(roman_string)
+    return nil unless roman_string.is_roman_numeral?
+
+    l = nil  # last
+    i = 0    # integer result
+
+    c = roman_string.to_s.upcase.split(//).reverse
+
+    c.each do |d|
+      if v = TABLE[d]
+        if l && l > v
+          i -= v
+        else
+          i += v
+        end
+        l = v
+      end
+    end
+
+    return i
+  end
+
+  alias_method :arabic, :to_integer
+
+  # Returns true iif +string+ is a roman numeral.
+
+  def is_roman_numeral?(string)
+    REGEXP =~ string
+  end
+
+  end
+
+end
+
+end # module English
+
+
+class Integer
+
+  def roman
+    English::RomanNumerals.roman(self) || ''
+  end
+
+  # Converts this integer to a roman numeral.
+
+  def to_s_roman
+    English::RomanNumerals.from_integer(self) || ''
+  end
+
+end
+
+
+class String
+
+  # Considers string a roman numeral numeral,
+  # and converts it to the corresponding integer.
+
+  def to_i_roman
+    English::RomanNumerals.to_integer(self)
+  end
+
+  # Returns true iif the subject is a roman numeral.
+
+  def is_roman_numeral?
+    English::RomanNumerals.is_roman_numeral?(self)
+  end
+
+end
+
+
+# # Quiz solution: filter that swaps roman and arabic numbers
+# if __FILE__ == $0
+#   ARGF.each do |line|
+#     line.chomp!
+#     if line.is_roman_numeral?
+#       puts line.to_i_roman
+#     else
+#       puts line.to_i.to_s_roman
+#     end
+#   end
+# end