mack-facets 0.8.2 → 0.8.3

data/lib/gems/extlib-0.9.8/lib/extlib/hash.rb

@@ -1,419 +0,0 @@
-class Hash
-  class << self
-    # Converts valid XML into a Ruby Hash structure.
-    #
-    # @param xml<String> A string representation of valid XML.
-    #
-    # @note Mixed content is treated as text and any tags in it are left unparsed
-    # @note Any attributes other than type on a node containing a text node will be
-    #   discarded
-    #
-    # @details [Typecasting]
-    #   Typecasting is performed on elements that have a +type+ attribute:
-    #   integer::
-    #   boolean:: Anything other than "true" evaluates to false.
-    #   datetime::
-    #     Returns a Time object. See Time documentation for valid Time strings.
-    #   date::
-    #     Returns a Date object. See Date documentation for valid Date strings.
-    #
-    # Keys are automatically converted to +snake_case+
-    #
-    # @example [Simple]
-    #   <user gender='m'>
-    #     <age type='integer'>35</age>
-    #     <name>Home Simpson</name>
-    #     <dob type='date'>1988-01-01</dob>
-    #     <joined-at type='datetime'>2000-04-28 23:01</joined-at>
-    #     <is-cool type='boolean'>true</is-cool>
-    #   </user>
-    #
-    #   evaluates to
-    #
-    #   { "user" => {
-    #       "gender"    => "m",
-    #       "age"       => 35,
-    #       "name"      => "Home Simpson",
-    #       "dob"       => DateObject( 1998-01-01 ),
-    #       "joined_at" => TimeObject( 2000-04-28 23:01),
-    #       "is_cool"   => true
-    #     }
-    #   }
-    #
-    # @example [Mixed Content]
-    #   <story>
-    #     A Quick <em>brown</em> Fox
-    #   </story>
-    #
-    #   evaluates to
-    #
-    #   { "story" => "A Quick <em>brown</em> Fox" }
-    #
-    # @details [Attributes other than type on a node containing text]
-    #   <story is-good='false'>
-    #     A Quick <em>brown</em> Fox
-    #   </story>
-    #
-    #   evaluates to
-    #
-    #   { "story" => "A Quick <em>brown</em> Fox" }
-    #
-    #   <bicep unit='inches' type='integer'>60</bicep>
-    #
-    #   evaluates with a typecast to an integer. But unit attribute is ignored.
-    #
-    #   { "bicep" => 60 }
-    def from_xml( xml )
-      ToHashParser.from_xml(xml)
-    end
-  end
-  
-  # This class has semantics of ActiveSupport's HashWithIndifferentAccess
-  # and we only have it so that people can write
-  # params[:key] instead of params['key'].
-  #
-  # @return <Mash> This hash as a Mash for string or symbol key access.
-  def to_mash
-    hash = Mash.new(self)
-    hash.default = default
-    hash
-  end
-
-  # @return <String> This hash as a query string
-  #
-  # @example
-  #   { :name => "Bob",
-  #     :address => {
-  #       :street => '111 Ruby Ave.',
-  #       :city => 'Ruby Central',
-  #       :phones => ['111-111-1111', '222-222-2222']
-  #     }
-  #   }.to_params
-  #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
-  def to_params
-    params = self.map { |k,v| normalize_param(k,v) }.join
-    params.chop! # trailing &
-    params
-  end
-
-  # @param key<Object> The key for the param.
-  # @param value<Object> The value for the param.
-  #
-  # @return <String> This key value pair as a param
-  #
-  # @example normalize_param(:name, "Bob") #=> "name=Bob&"
-  def normalize_param(key, value)
-    param = ''
-    stack = []
-
-    if value.is_a?(Array)
-      param << value.map { |element| normalize_param("#{key}[]", element) }.join
-    elsif value.is_a?(Hash)
-      stack << [key,value]
-    else
-      param << "#{key}=#{value}&"
-    end
-
-    stack.each do |parent, hash|
-      hash.each do |key, value|
-        if value.is_a?(Hash)
-          stack << ["#{parent}[#{key}]", value]
-        else
-          param << normalize_param("#{parent}[#{key}]", value)
-        end
-      end
-    end
-
-    param
-  end
-
-  # @param *allowed<Array[(String, Symbol)]> The hash keys to include.
-  #
-  # @return <Hash> A new hash with only the selected keys.
-  #
-  # @example
-  #   { :one => 1, :two => 2, :three => 3 }.only(:one)
-  #     #=> { :one => 1 }
-  def only(*allowed)
-    hash = {}
-    allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
-    hash
-  end
-
-  # @param *rejected<Array[(String, Symbol)] The hash keys to exclude.
-  #
-  # @return <Hash> A new hash without the selected keys.
-  #
-  # @example
-  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
-  #     #=> { :two => 2, :three => 3 }
-  def except(*rejected)
-    hash = self.dup
-    rejected.each {|k| hash.delete(k) }
-    hash
-  end
-
-  # @return <String> The hash as attributes for an XML tag.
-  #
-  # @example
-  #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
-  #     #=> 'one="1" two="TWO"'
-  def to_xml_attributes
-    map do |k,v|
-      %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
-    end.join(' ')
-  end
-
-  alias_method :to_html_attributes, :to_xml_attributes
-
-  # @param html_class<#to_s>
-  #   The HTML class to add to the :class key. The html_class will be
-  #   concatenated to any existing classes.
-  #
-  # @example hash[:class] #=> nil
-  # @example hash.add_html_class!(:selected)
-  # @example hash[:class] #=> "selected"
-  # @example hash.add_html_class!("class1 class2")
-  # @example hash[:class] #=> "selected class1 class2"
-  def add_html_class!(html_class)
-    if self[:class]
-      self[:class] = "#{self[:class]} #{html_class}"
-    else
-      self[:class] = html_class.to_s
-    end
-  end
-
-  # Converts all keys into string values. This is used during reloading to
-  # prevent problems when classes are no longer declared.
-  #
-  # @return <Array> An array of they hash's keys
-  #
-  # @example 
-  #   hash = { One => 1, Two => 2 }.proctect_keys!
-  #   hash # => { "One" => 1, "Two" => 2 }
-  def protect_keys!
-    keys.each {|key| self[key.to_s] = delete(key) }
-  end
-
-  # Attempts to convert all string keys into Class keys. We run this after
-  # reloading to convert protected hashes back into usable hashes.
-  #
-  # @example
-  #   # Provided that classes One and Two are declared in this scope:
-  #   hash = { "One" => 1, "Two" => 2 }.unproctect_keys!
-  #   hash # => { One => 1, Two => 2 }
-  def unprotect_keys!
-    keys.each do |key|
-      (self[Object.full_const_get(key)] = delete(key)) rescue nil
-    end
-  end
-
-  # Destructively and non-recursively convert each key to an uppercase string,
-  # deleting nil values along the way.
-  #
-  # @return <Hash> The newly environmentized hash.
-  #
-  # @example
-  #   { :name => "Bob", :contact => { :email => "bob@bob.com" } }.environmentize_keys!
-  #     #=> { "NAME" => "Bob", "CONTACT" => { :email => "bob@bob.com" } }
-  def environmentize_keys!
-    keys.each do |key|
-      val = delete(key)
-      next if val.nil?
-      self[key.to_s.upcase] = val
-    end
-    self
-  end
-end
-
-require 'rexml/parsers/streamparser'
-require 'rexml/parsers/baseparser'
-require 'rexml/light/node'
-
-# This is a slighly modified version of the XMLUtilityNode from
-# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
-# It's mainly just adding vowels, as I ht cd wth n vwls :)
-# This represents the hard part of the work, all I did was change the
-# underlying parser.
-class REXMLUtilityNode
-  attr_accessor :name, :attributes, :children, :type
-  cattr_accessor :typecasts, :available_typecasts
-
-  self.typecasts = {}
-  self.typecasts["integer"]       = lambda{|v| v.nil? ? nil : v.to_i}
-  self.typecasts["boolean"]       = lambda{|v| v.nil? ? nil : (v.strip != "false")}
-  self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
-  self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
-  self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
-  self.typecasts["decimal"]       = lambda{|v| BigDecimal(v)}
-  self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
-  self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
-  self.typecasts["symbol"]        = lambda{|v| v.to_sym}
-  self.typecasts["string"]        = lambda{|v| v.to_s}
-  self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
-  self.typecasts["base64Binary"]  = lambda{|v| v.unpack('m').first }
-
-  self.available_typecasts = self.typecasts.keys
-
-  def initialize(name, attributes = {})
-    @name         = name.tr("-", "_")
-    # leave the type alone if we don't know what it is
-    @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
-
-    @nil_element  = attributes.delete("nil") == "true"
-    @attributes   = undasherize_keys(attributes)
-    @children     = []
-    @text         = false
-  end
-
-  def add_node(node)
-    @text = true if node.is_a? String
-    @children << node
-  end
-
-  def to_hash
-    if @type == "file"
-      f = StringIO.new((@children.first || '').unpack('m').first)
-      class << f
-        attr_accessor :original_filename, :content_type
-      end
-      f.original_filename = attributes['name'] || 'untitled'
-      f.content_type = attributes['content_type'] || 'application/octet-stream'
-      return {name => f}
-    end
-
-    if @text
-      return { name => typecast_value( translate_xml_entities( inner_html ) ) }
-    else
-      #change repeating groups into an array
-      groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
-
-      out = nil
-      if @type == "array"
-        out = []
-        groups.each do |k, v|
-          if v.size == 1
-            out << v.first.to_hash.entries.first.last
-          else
-            out << v.map{|e| e.to_hash[k]}
-          end
-        end
-        out = out.flatten
-
-      else # If Hash
-        out = {}
-        groups.each do |k,v|
-          if v.size == 1
-            out.merge!(v.first)
-          else
-            out.merge!( k => v.map{|e| e.to_hash[k]})
-          end
-        end
-        out.merge! attributes unless attributes.empty?
-        out = out.empty? ? nil : out
-      end
-
-      if @type && out.nil?
-        { name => typecast_value(out) }
-      else
-        { name => out }
-      end
-    end
-  end
-
-  # Typecasts a value based upon its type. For instance, if
-  # +node+ has #type == "integer",
-  # {{[node.typecast_value("12") #=> 12]}}
-  #
-  # @param value<String> The value that is being typecast.
-  #
-  # @details [:type options]
-  #   "integer"::
-  #     converts +value+ to an integer with #to_i
-  #   "boolean"::
-  #     checks whether +value+, after removing spaces, is the literal
-  #     "true"
-  #   "datetime"::
-  #     Parses +value+ using Time.parse, and returns a UTC Time
-  #   "date"::
-  #     Parses +value+ using Date.parse
-  #
-  # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
-  #   The result of typecasting +value+.
-  #
-  # @note
-  #   If +self+ does not have a "type" key, or if it's not one of the
-  #   options specified above, the raw +value+ will be returned.
-  def typecast_value(value)
-    return value unless @type
-    proc = self.class.typecasts[@type]
-    proc.nil? ? value : proc.call(value)
-  end
-
-  # Convert basic XML entities into their literal values.
-  #
-  # @param value<#gsub> An XML fragment.
-  #
-  # @return <#gsub> The XML fragment after converting entities.
-  def translate_xml_entities(value)
-    value.gsub(/&lt;/,   "<").
-          gsub(/&gt;/,   ">").
-          gsub(/&quot;/, '"').
-          gsub(/&apos;/, "'").
-          gsub(/&amp;/,  "&")
-  end
-
-  # Take keys of the form foo-bar and convert them to foo_bar
-  def undasherize_keys(params)
-    params.keys.each do |key, value|
-      params[key.tr("-", "_")] = params.delete(key)
-    end
-    params
-  end
-
-  # Get the inner_html of the REXML node.
-  def inner_html
-    @children.join
-  end
-
-  # Converts the node into a readable HTML node.
-  #
-  # @return <String> The HTML node in text form.
-  def to_html
-    attributes.merge!(:type => @type ) if @type
-    "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
-  end
-
-  # @alias #to_html #to_s
-  def to_s
-    to_html
-  end
-end
-
-class ToHashParser
-
-  def self.from_xml(xml)
-    stack = []
-    parser = REXML::Parsers::BaseParser.new(xml)
-
-    while true
-      event = parser.pull
-      case event[0]
-      when :end_document
-        break
-      when :end_doctype, :start_doctype
-        # do nothing
-      when :start_element
-        stack.push REXMLUtilityNode.new(event[1], event[2])
-      when :end_element
-        if stack.size > 1
-          temp = stack.pop
-          stack.last.add_node(temp)
-        end
-      when :text, :cdata
-        stack.last.add_node(event[1]) unless event[1].strip.length == 0
-      end
-    end
-    stack.pop.to_hash
-  end
-end

data/lib/gems/extlib-0.9.8/lib/extlib/inflection.rb

@@ -1,435 +0,0 @@
-module Extlib
-
-  # = English Nouns Number Inflection.
-  #
-  # This module provides english singular <-> plural noun inflections.
-  module Inflection
-
-    class << self
-      # Take an underscored name and make it into a camelized name
-      #
-      # @example
-      #   "egg_and_hams".classify #=> "EggAndHam"
-      #   "post".classify #=> "Post"
-      #
-      def classify(name)
-        camelize(singularize(name.to_s.sub(/.*\./, '')))
-      end
-
-      # By default, camelize converts strings to UpperCamelCase.
-      #
-      # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
-      #
-      # @example
-      #   "active_record".camelize #=> "ActiveRecord"
-      #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
-      #
-      def camelize(lower_case_and_underscored_word, *args)
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-      end
-
-
-      # The reverse of +camelize+. Makes an underscored form from the expression in the string.
-      #
-      # Changes '::' to '/' to convert namespaces to paths.
-      #
-      # @example
-      #   "ActiveRecord".underscore #=> "active_record"
-      #   "ActiveRecord::Errors".underscore #=> active_record/errors
-      #
-      def underscore(camel_cased_word)
-        camel_cased_word.to_const_path
-      end
-
-      # Capitalizes the first word and turns underscores into spaces and strips _id.
-      # Like titleize, this is meant for creating pretty output.
-      #
-      # @example
-      #   "employee_salary" #=> "Employee salary"
-      #   "author_id" #=> "Author"
-      def humanize(lower_case_and_underscored_word)
-        lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
-      end
-
-      # Removes the module part from the expression in the string
-      #
-      # @example
-      #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
-      #   "Inflections".demodulize #=> "Inflections"
-      def demodulize(class_name_in_module)
-        class_name_in_module.to_s.gsub(/^.*::/, '')
-      end
-
-      # Create the name of a table like Rails does for models to table names. This method
-      # uses the pluralize method on the last word in the string.
-      #
-      # @example
-      #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
-      #   "egg_and_ham".tableize #=> "egg_and_hams"
-      #   "fancyCategory".tableize #=> "fancy_categories"
-      def tableize(class_name)
-        pluralize(class_name.to_const_path.gsub(/\//, '_'))
-      end
-
-      # Creates a foreign key name from a class name.
-      #
-      # @example
-      #   "Message".foreign_key #=> "message_id"
-      #   "Admin::Post".foreign_key #=> "post_id"
-      def foreign_key(class_name, key = "id")
-        underscore(demodulize(class_name.to_s)) << "_" << key.to_s
-      end
-
-      # Constantize tries to find a declared constant with the name specified
-      # in the string. It raises a NameError when the name is not in CamelCase
-      # or is not initialized.
-      #
-      # @example
-      #   "Module".constantize #=> Module
-      #   "Class".constantize #=> Class
-      def constantize(camel_cased_word)
-        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-          raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-        end
-
-        Object.module_eval("::#{$1}", __FILE__, __LINE__)
-      end
-    end
-
-    @singular_of = {}
-    @plural_of = {}
-
-    @singular_rules = []
-    @plural_rules = []
-
-    class << self
-      # Defines a general inflection exception case.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   singular form of the word
-      # plural<String>::
-      #   plural form of the word
-      #
-      # ==== Examples
-      #
-      # Here we define erratum/errata exception case:
-      #
-      # English::Inflect.word "erratum", "errata"
-      #
-      # In case singular and plural forms are the same omit
-      # second argument on call:
-      #
-      # English::Inflect.word 'information'
-      def word(singular, plural=nil)
-        plural = singular unless plural
-        singular_word(singular, plural)
-        plural_word(singular, plural)
-      end
-
-      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
-
-
-      # Define a singularization exception.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   singular form of the word
-      # plural<String>::
-      #   plural form of the word
-      def singular_word(singular, plural)
-        @singular_of[plural] = singular
-        @singular_of[plural.capitalize] = singular.capitalize
-      end
-
-      # Define a pluralization exception.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   singular form of the word
-      # plural<String>::
-      #   plural form of the word
-      def plural_word(singular, plural)
-        @plural_of[singular] = plural
-        @plural_of[singular.capitalize] = plural.capitalize
-      end
-
-      # Define a general rule.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   ending of the word in singular form
-      # plural<String>::
-      #   ending of the word in plural form
-      # whole_word<Boolean>::
-      #   for capitalization, since words can be
-      #   capitalized (Man => Men)      #
-      # ==== Examples
-      # Once the following rule is defined:
-      # English::Inflect.rule 'y', 'ies'
-      #
-      # You can see the following results:
-      # irb> "fly".plural
-      # => flies
-      # irb> "cry".plural
-      # => cries
-      # Define a general rule.
-
-      def rule(singular, plural, whole_word = false)
-        singular_rule(singular, plural)
-        plural_rule(singular, plural)
-        word(singular, plural) if whole_word
-      end
-
-      # Define a singularization rule.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   ending of the word in singular form
-      # plural<String>::
-      #   ending of the word in plural form
-      #
-      # ==== Examples
-      # Once the following rule is defined:
-      # English::Inflect.singular_rule 'o', 'oes'
-      #
-      # You can see the following results:
-      # irb> "heroes".singular
-      # => hero
-      def singular_rule(singular, plural)
-        @singular_rules << [singular, plural]
-      end
-
-      # Define a plurualization rule.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   ending of the word in singular form
-      # plural<String>::
-      #   ending of the word in plural form
-      #
-      # ==== Examples
-      # Once the following rule is defined:
-      # English::Inflect.singular_rule 'fe', 'ves'
-      #
-      # You can see the following results:
-      # irb> "wife".plural
-      # => wives
-      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 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
-
-      attr_reader :singular_of, :plural_of
-
-      # Convert an English word from plurel to singular.
-      #
-      #   "boys".singular      #=> boy
-      #   "tomatoes".singular  #=> tomato
-      #
-      # ==== Parameters
-      # word<String>:: word to singularize
-      #
-      # ==== Returns
-      # <String>:: singularized form of word
-      #
-      # ==== Notes
-      # Aliased as singularize (a Railism)
-      def singular(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
-      end
-
-      # Alias for #singular (a Railism).
-      #
-      alias_method(:singularize, :singular)
-
-      # Convert an English word from singular to plurel.
-      #
-      #   "boy".plural     #=> boys
-      #   "tomato".plural  #=> tomatoes
-      #
-      # ==== Parameters
-      # word<String>:: word to pluralize
-      #
-      # ==== Returns
-      # <String>:: pluralized form of word
-      #
-      # ==== Notes
-      # Aliased as pluralize (a Railism)
-      def plural(word)
-        # special exceptions
-        return "" if word == ""
-        if result = plural_of[word]
-          return result.dup
-        end
-        result = word.dup
-        regex, hash = pluralization_rules
-        result.sub!(regex) {|m| hash[m]}
-        plural_of[word] = result
-        return result
-      end
-
-      # Alias for #plural (a Railism).
-      alias_method(:pluralize, :plural)
-    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 'grass'
-    word 'rain'
-    word 'milk'
-    word 'rice'
-    word 'plurals'
-    word 'postgres'
-    word 'status'
-
-    # Two arguments defines a singular and plural exception.
-    word 'status'    , 'status'
-    word 'Swiss'     , 'Swiss'
-    word 'life'      , 'lives'
-    word 'wife'      , 'wives'
-    word 'goose'     , 'geese'
-    word 'criterion' , 'criteria'
-    word 'alias'     , 'aliases'
-    word 'status'    , 'statuses'
-    word 'axis'      , 'axes'
-    word 'crisis'    , 'crises'
-    word 'testis'    , 'testes'
-    word 'potato'    , 'potatoes'
-    word 'tomato'    , 'tomatoes'
-    word 'buffalo'   , 'buffaloes'
-    word 'torpedo'   , 'torpedoes'
-    word 'quiz'      , 'quizzes'
-    word 'matrix'    , 'matrices'
-    word 'vertex'    , 'vertices'
-    word 'index'     , 'indices'
-    word 'ox'        , 'oxen'
-    word 'mouse'     , 'mice'
-    word 'louse'     , 'lice'
-    word 'thesis'    , 'theses'
-    word 'thief'     , 'thieves'
-    word 'analysis'  , 'analyses'
-    word 'erratum'   , 'errata'
-    word 'phenomenon', 'phenomena'
-    word 'octopus'   , 'octopi'
-    word 'thesaurus' , 'thesauri'
-    word 'movie'     , 'movies'
-    word 'cactus'    , 'cacti'
-    word 'plus'      , 'plusses'
-    word 'cross'     , 'crosses'
-    word 'medium'    , 'media'
-    word 'cow'       , 'kine'
-    word 'datum'     , 'data'
-    word 'basis'     , 'bases'
-    word 'diagnosis' , 'diagnoses'
-
-    # One-way singularization exception (convert plural to singular).
-
-    # General rules.
-    rule 'person' , 'people', true
-    rule 'shoe'   , 'shoes', true
-    rule 'hive'   , 'hives', true
-    rule 'man'    , 'men', true
-    rule 'child'  , 'children', true
-    rule 'news'   , 'news', true
-    rule 'rf'   , 'rves'
-    rule 'af'   , 'aves'
-    rule 'ero'  , 'eroes'
-    rule 'man'  , 'men'
-    rule 'ch'   , 'ches'
-    rule 'sh'   , 'shes'
-    rule 'ss'   , 'sses'
-    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 'afe'  , 'aves'
-    rule 'ouse' , 'ouses'
-    # more cases of words ending in -oses not being singularized properly
-    # than cases of words ending in -osis
-#    rule 'osis' , 'oses'
-    rule 'ox'   , 'oxes'
-    rule 'us'   , 'uses'
-    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 'fe' , 'ves' # safe, wife
-    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
-    Extlib::Inflection.singular(self)
-  end
-  alias_method(:singularize, :singular)
-  def plural
-    Extlib::Inflection.plural(self)
-  end
-  alias_method(:pluralize, :plural)
-end