mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,47 @@
+warn "Use english/style for future version."
+
+module English #:nodoc:
+
+  module Dresner
+
+    extend self
+
+    # Scramble the inner characters of words leaving the text still readable
+    # (research at Cambridge University, code by KurtDresner).
+    #
+    # For example, the above text may result in:
+    #
+    #   Srblamce the iennr cchrteaars of wodrs lvenaig the txet stlil rbeaadle
+    #   (rreceash at Cbamigdre Uverintisy, cdoe by KrneruestDr?)
+
+    def dresner(string)
+      string.gsub(/\B\w+\B/){$&.split(//).sort_by{rand}}
+    end
+
+  end
+
+end
+
+# Extensions to String.
+
+class String #:nodoc:
+
+  # Scramble the inner characters of words leaving the text still readable
+  # (research at Cambridge University, code by KurtDresner).
+  #
+  # For example, the above text may result in:
+  #
+  #   Srblamce the iennr cchrteaars of wodrs lvenaig the txet stlil rbeaadle
+  #   (rreceash at Cbamigdre Uverintisy, cdoe by KrneruestDr?)
+
+  def dresner
+    English::Dresner.dresner(self)
+  end
+
+  # Inplace version of #dresner method.
+
+  def dresner!
+    replace(dresner)
+  end
+
+end

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

@@ -0,0 +1,299 @@
+module English
+
+  # = English Nouns Number Inflection.
+  #
+  # This module provides english singular <-> plural noun inflections.
+  module Inflect
+
+    @singular_of = {}
+    @plural_of = {}
+
+    @singular_rules = []
+    @plural_rules = []
+
+    # This class provides the DSL for creating inflections, you can add additional rules.
+    # Examples:
+    #
+    #   word "ox", "oxen"
+    #   word "octopus", "octopi"
+    #   word "man", "men"
+    #
+    #   rule "lf", "lves"
+    #
+    #   word "equipment"
+    #
+    # Rules are evaluated by size, so rules you add to override specific cases should be longer than the rule
+    # it overrides. For instance, if you want "pta" to pluralize to "ptas", even though a general purpose rule
+    # for "ta" => "tum" already exists, simply add a new rule for "pta" => "ptas", and it will automatically win
+    # since it is longer than the old rule.
+    #
+    # Also, single-word exceptions win over general words ("ox" pluralizes to "oxen", because it's a single word
+    # exception, even though "fox" pluralizes to "foxes")
+    class << self
+      # Define a general two-way exception.
+      #
+      # This also defines a general rule, so foo_child will correctly become
+      # foo_children.
+      #
+      # Whole words also work if they are capitalized (Goose => Geese).
+      def word(singular, plural=nil)
+        plural = singular unless plural
+        singular_word(singular, plural)
+        plural_word(singular, plural)
+        rule(singular, plural)
+      end
+
+      # Define a singularization exception.
+      def singular_word(singular, plural)
+        @singular_of[plural] = singular
+        @singular_of[plural.capitalize] = singular.capitalize
+      end
+
+      # Define a pluralization exception.
+      def plural_word(singular, plural)
+        @plural_of[singular] = plural
+        @plural_of[singular.capitalize] = plural.capitalize
+      end
+
+      # Define a general rule.
+      def rule(singular, plural)
+        singular_rule(singular, plural)
+        plural_rule(singular, plural)
+      end
+
+      # Define a singularization rule.
+      def singular_rule(singular, plural)
+        @singular_rules << [singular, plural]
+      end
+
+      # Define a plurualization rule.
+      def plural_rule(singular, plural)
+        @plural_rules << [singular, plural]
+      end
+
+      # Read prepared singularization rules.
+      def singularization_rules
+        if defined?(@singularization_regex) && @singularization_regex
+          return [@singularization_regex, @singularization_hash]
+        end
+        # No sorting needed: Regexen match on longest string
+        @singularization_regex = Regexp.new("(" + @singular_rules.map {|s,p| p}.join("|") + ")$", "i")
+        @singularization_hash  = Hash[*@singular_rules.flatten].invert
+        [@singularization_regex, @singularization_hash]
+      end
+
+      # Read prepared singularization rules.
+      #def singularization_rules
+      #  return @singularization_rules if @singularization_rules
+      #  sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
+      #  @singularization_rules = sorted.collect do |s, p|
+      #    [ /#{p}$/, "#{s}" ]
+      #  end
+      #end
+
+      # Read prepared pluralization rules.
+      def pluralization_rules
+        if defined?(@pluralization_regex) && @pluralization_regex
+          return [@pluralization_regex, @pluralization_hash]
+        end
+        @pluralization_regex = Regexp.new("(" + @plural_rules.map {|s,p| s}.join("|") + ")$", "i")
+        @pluralization_hash = Hash[*@plural_rules.flatten]
+        [@pluralization_regex, @pluralization_hash]
+      end
+
+      # Read prepared pluralization rules.
+      #def pluralization_rules
+      #  return @pluralization_rules if @pluralization_rules
+      #  sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
+      #  @pluralization_rules = sorted.collect do |s, p|
+      #    [ /#{s}$/, "#{p}" ]
+      #  end
+      #end
+
+      #
+      def singular_of ; @singular_of ; end
+
+      #
+      def plural_of   ; @plural_of   ; end
+
+      # Convert an English word from plurel to singular.
+      #
+      #   "boys".singular      #=> boy
+      #   "tomatoes".singular  #=> tomato
+      #
+      def singular(word)
+        return "" if word == ""
+        if result = singular_of[word]
+          return result.dup
+        end
+        result = word.dup
+
+        regex, hash = singularization_rules
+        result.sub!(regex) {|m| hash[m]}
+        singular_of[word] = result
+        return result
+        #singularization_rules.each do |(match, replacement)|
+        #  break if result.gsub!(match, replacement)
+        #end
+        #return result
+      end
+
+      # Alias for #singular (a Railism).
+      #
+      alias_method(:singularize, :singular)
+
+      # Convert an English word from singular to plurel.
+      #
+      #   "boy".plural     #=> boys
+      #   "tomato".plural  #=> tomatoes
+      #
+      def plural(word)
+        return "" if word == ""
+        if result = plural_of[word]
+          return result.dup
+        end
+        #return self.dup if /s$/ =~ self # ???
+        result = word.dup
+
+        regex, hash = pluralization_rules
+        result.sub!(regex) {|m| hash[m]}
+        plural_of[word] = result
+        return result
+        #pluralization_rules.each do |(match, replacement)|
+        #  break if result.gsub!(match, replacement)
+        #end
+        #return result
+      end
+
+      # Alias for #plural (a Railism).
+      alias_method(:pluralize, :plural)
+
+      # Clear all rules.
+      def clear(type = :all)
+        if type == :singular || type == :all
+          @singular_of = {}
+          @singular_rules = []
+          @singularization_rules, @singularization_regex = nil, nil
+        end
+        if type == :plural || type == :all
+          @singular_of = {}
+          @singular_rules = []
+          @singularization_rules, @singularization_regex = nil, nil
+        end
+      end
+    end
+
+    # One argument means singular and plural are the same.
+
+    word 'equipment'
+    word 'information'
+    word 'money'
+    word 'species'
+    word 'series'
+    word 'fish'
+    word 'sheep'
+    word 'moose'
+    word 'hovercraft'
+    word 'news'
+    word 'rice'
+    word 'plurals'
+
+    # Two arguments defines a singular and plural exception.
+
+    word 'Swiss'     , 'Swiss'
+    word 'alias'     , 'aliases'
+    word 'analysis'  , 'analyses'
+    #word 'axis'      , 'axes'
+    word 'basis'     , 'bases'
+    word 'buffalo'   , 'buffaloes'
+    word 'child'     , 'children'
+    #word 'cow'       , 'kine'
+    word 'crisis'    , 'crises'
+    word 'criterion' , 'criteria'
+    word 'datum'     , 'data'
+    word 'goose'     , 'geese'
+    word 'hive'      , 'hives'
+    word 'index'     , 'indices'
+    word 'life'      , 'lives'
+    word 'louse'     , 'lice'
+    word 'man'       , 'men'
+    word 'matrix'    , 'matrices'
+    word 'medium'    , 'media'
+    word 'mouse'     , 'mice'
+    word 'movie'     , 'movies'
+    word 'octopus'   , 'octopi'
+    word 'ox'        , 'oxen'
+    word 'person'    , 'people'
+    word 'potato'    , 'potatoes'
+    word 'quiz'      , 'quizzes'
+    word 'shoe'      , 'shoes'
+    word 'status'    , 'statuses'
+    word 'testis'    , 'testes'
+    word 'thesis'    , 'theses'
+    word 'thief'     , 'thieves'
+    word 'tomato'    , 'tomatoes'
+    word 'torpedo'   , 'torpedoes'
+    word 'vertex'    , 'vertices'
+    word 'virus'     , 'viri'
+    word 'wife'      , 'wives'
+
+    # One-way singularization exception (convert plural to singular).
+
+    singular_word 'cactus', 'cacti'
+
+    # One-way pluralizaton exception (convert singular to plural).
+
+    plural_word 'axis', 'axes'
+
+    # General rules.
+
+    rule 'rf'     , 'rves'
+    rule 'ero'    , 'eroes'
+    rule 'ch'     , 'ches'
+    rule 'sh'     , 'shes'
+    rule 'ss'     , 'sses'
+    #rule 'ess'  , 'esses'
+    rule 'ta'     , 'tum'
+    rule 'ia'     , 'ium'
+    rule 'ra'     , 'rum'
+    rule 'ay'     , 'ays'
+    rule 'ey'     , 'eys'
+    rule 'oy'     , 'oys'
+    rule 'uy'     , 'uys'
+    rule 'y'      , 'ies'
+    rule 'x'      , 'xes'
+    rule 'lf'     , 'lves'
+    rule 'ffe'    , 'ffes'
+    rule 'af'     , 'aves'
+    rule 'us'     , 'uses'
+    rule 'ouse'   , 'ouses'
+    rule 'osis'   , 'oses'
+    rule 'ox'     , 'oxes'
+    rule ''       , 's'
+
+    # One-way singular rules.
+
+    singular_rule 'of' , 'ofs' # proof
+    singular_rule 'o'  , 'oes' # hero, heroes
+    #singular_rule 'f'  , 'ves'
+
+    # One-way plural rules.
+
+    plural_rule 's'   , 'ses'
+    plural_rule 'ive' , 'ives' # don't want to snag wife
+    plural_rule 'fe'  , 'ves'  # don't want to snag perspectives 
+  end
+end
+
+
+class String
+  def singular
+    English::Inflect.singular(self)
+  end
+  alias_method(:singularize, :singular)
+
+  def plural
+    English::Inflect.plural(self)
+  end
+  alias_method(:pluralize, :plural)
+end

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

@@ -0,0 +1,37 @@
+warn "Use english/style for future versions."
+
+module English #:nodoc:
+
+  module Jumble
+
+    extend self
+
+    # Jumble string.
+
+    def jumble(string)
+      j = ''
+      string.split(//).each_with_index{ |c,i| j << ( i % 2 == 0 ? c.downcase : c.upcase ) }
+      j
+    end
+
+  end
+
+end
+
+# Extensions to String.
+
+class String #:nodoc:
+
+  # Jumble string.
+
+  def jumble
+    English::Jumble.jumble(self)
+  end
+
+  # In-place version of #jumble.
+
+  def jumble!
+    replace(jumble)
+  end
+
+end

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

@@ -0,0 +1,78 @@
+# = title:
+#   Levenshtein Distance Algorithm
+#
+# = synopsis:
+#   The Levenshtein distance is a measure of how similar two strings s and t are,
+#   calculated as the number of deletions/insertions/substitutions needed to
+#   transform s into t. The greater the distance, the more the strings differ.
+#
+#   The Levenshtein distance is also sometimes referred to as the
+#   easier-to-pronounce-and-spell 'edit distance'.
+#
+# = author:
+#   Paul Battley (pbattley@gmail.com)
+
+module English # :nodoc:
+
+# Levenshtein distance algorithm implementation for Ruby, with UTF-8 support.
+#
+# The Levenshtein distance is a measure of how similar two strings s and t are,
+# calculated as the number of deletions/insertions/substitutions needed to
+# transform s into t. The greater the distance, the more the strings differ.
+#
+# The Levenshtein distance is also sometimes referred to as the
+# easier-to-pronounce-and-spell 'edit distance'.
+
+module Levenshtein
+
+  extend self
+
+  # Calculate the Levenshtein distance between two strings +str1+ and +str2+.
+  # +str1+ and +str2+ should be ASCII, UTF-8, or a one-byte-per character encoding such
+  # as ISO-8859-*.
+  #
+  # The strings will be treated as UTF-8 if $KCODE is set appropriately (i.e. 'u').
+  # Otherwise, the comparison will be performed byte-by-byte. There is no specific support
+  # for Shift-JIS or EUC strings.
+  #
+  # When using Unicode text, be aware that this algorithm does not perform normalisation.
+  # If there is a possibility of different normalised forms being used, normalisation
+  # should be performed beforehand.
+
+  def distance(str1, str2)
+    if $KCODE =~ /^U/i
+      unpack_rule = 'U*'
+    else
+      unpack_rule = 'C*'
+    end
+    s = str1.unpack(unpack_rule)
+    t = str2.unpack(unpack_rule)
+    n = s.length
+    m = t.length
+    return m if (0 == n)
+    return n if (0 == m)
+
+    d = (0..m).to_a
+    x = nil
+
+    (0...n).each do |i|
+      e = i+1
+      (0...m).each do |j|
+        cost = (s[i] == t[j]) ? 0 : 1
+        x = [
+          d[j+1] + 1, # insertion
+          e + 1,      # deletion
+          d[j] + cost # substitution
+        ].min
+        d[j] = e
+        e = x
+      end
+      d[m] = x
+    end
+
+    return x
+  end
+
+end
+
+end