motion_support 0.0.1 → 0.0.2

data/motion/inflector/methods.rb

@@ -0,0 +1,322 @@
+# encoding: utf-8
+
+module MotionSupport
+  # The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
+  # and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
+  # in inflections.rb.
+  #
+  # The Rails core team has stated patches for the inflections library will not be accepted
+  # in order to avoid breaking legacy applications which may be relying on errant inflections.
+  # If you discover an incorrect inflection and require it for your application, you'll need
+  # to correct it yourself (explained below).
+  module Inflector
+    extend self
+
+    # Returns the plural form of the word in the string.
+    #
+    #   "post".pluralize             # => "posts"
+    #   "octopus".pluralize          # => "octopi"
+    #   "sheep".pluralize            # => "sheep"
+    #   "words".pluralize            # => "words"
+    #   "CamelOctopus".pluralize     # => "CamelOctopi"
+    def pluralize(word)
+      apply_inflections(word, inflections.plurals)
+    end
+
+    # The reverse of +pluralize+, returns the singular form of a word in a string.
+    #
+    #   "posts".singularize            # => "post"
+    #   "octopi".singularize           # => "octopus"
+    #   "sheep".singularize            # => "sheep"
+    #   "word".singularize             # => "word"
+    #   "CamelOctopi".singularize      # => "CamelOctopus"
+    def singularize(word)
+      apply_inflections(word, inflections.singulars)
+    end
+
+    # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+    # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+    #
+    # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+    #
+    #   "active_model".camelize                # => "ActiveModel"
+    #   "active_model".camelize(:lower)        # => "activeModel"
+    #   "active_model/errors".camelize         # => "ActiveModel::Errors"
+    #   "active_model/errors".camelize(:lower) # => "activeModel::Errors"
+    #
+    # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
+    # though there are cases where that does not hold:
+    #
+    #   "SSLError".underscore.camelize # => "SslError"
+    def camelize(term, uppercase_first_letter = true)
+      string = term.to_s
+      if uppercase_first_letter
+        string = string.sub(/^[a-z\d]*/) { inflections.acronyms[$&] || $&.capitalize }
+      else
+        string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { $&.downcase }
+      end
+      string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }.gsub('/', '::')
+    end
+
+    # Makes an underscored, lowercase form from the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    #   "ActiveModel".underscore         # => "active_model"
+    #   "ActiveModel::Errors".underscore # => "active_model/errors"
+    #
+    # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
+    # though there are cases where that does not hold:
+    #
+    #   "SSLError".underscore.camelize # => "SslError"
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!('::', '/')
+      word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    # Capitalizes the first word and turns underscores into spaces and strips a
+    # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+    #
+    #   "employee_salary" # => "Employee salary"
+    #   "author_id"       # => "Author"
+    def humanize(lower_case_and_underscored_word)
+      result = lower_case_and_underscored_word.to_s.dup
+      inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+      result.gsub!(/_id$/, "")
+      result.tr!('_', ' ')
+      result.gsub(/([a-z\d]*)/i) { |match|
+        "#{inflections.acronyms[match] || match.downcase}"
+      }.gsub(/^\w/) { $&.upcase }
+    end
+
+    # Capitalizes all the words and replaces some characters in the string to create
+    # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+    # used in the Rails internals.
+    #
+    # +titleize+ is also aliased as +titlecase+.
+    #
+    #   "man from the boondocks".titleize   # => "Man From The Boondocks"
+    #   "x-men: the last stand".titleize    # => "X Men: The Last Stand"
+    #   "TheManWithoutAPast".titleize       # => "The Man Without A Past"
+    #   "raiders_of_the_lost_ark".titleize  # => "Raiders Of The Lost Ark"
+    def titleize(word)
+      humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
+    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.
+    #
+    #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
+    #   "egg_and_ham".tableize     # => "egg_and_hams"
+    #   "fancyCategory".tableize   # => "fancy_categories"
+    def tableize(class_name)
+      pluralize(underscore(class_name))
+    end
+
+    # Create a class name from a plural table name like Rails does for table names to models.
+    # Note that this returns a string and not a Class. (To convert to an actual class
+    # follow +classify+ with +constantize+.)
+    #
+    #   "egg_and_hams".classify # => "EggAndHam"
+    #   "posts".classify        # => "Post"
+    #
+    # Singular names are not handled correctly:
+    #   "business".classify     # => "Busines"
+    def classify(table_name)
+      # strip out any leading schema name
+      camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+    end
+
+    # Replaces underscores with dashes in the string.
+    #
+    #   "puni_puni".dasherize # => "puni-puni"
+    def dasherize(underscored_word)
+      underscored_word.tr('_', '-')
+    end
+
+    # Removes the module part from the expression in the string:
+    #
+    #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+    #   "Inflections".demodulize                                       # => "Inflections"
+    #
+    # See also +deconstantize+.
+    def demodulize(path)
+      path = path.to_s
+      if i = path.rindex('::')
+        path[(i+2)..-1]
+      else
+        path
+      end
+    end
+
+    # Removes the rightmost segment from the constant expression in the string:
+    #
+    #   "Net::HTTP".deconstantize   # => "Net"
+    #   "::Net::HTTP".deconstantize # => "::Net"
+    #   "String".deconstantize      # => ""
+    #   "::String".deconstantize    # => ""
+    #   "".deconstantize            # => ""
+    #
+    # See also +demodulize+.
+    def deconstantize(path)
+      path.to_s[0...(path.rindex('::') || 0)] # implementation based on the one in facets' Module#spacename
+    end
+
+    # Creates a foreign key name from a class name.
+    # +separate_class_name_and_id_with_underscore+ sets whether
+    # the method should put '_' between the name and 'id'.
+    #
+    #   "Message".foreign_key        # => "message_id"
+    #   "Message".foreign_key(false) # => "messageid"
+    #   "Admin::Post".foreign_key    # => "post_id"
+    def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+      underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+    end
+
+    # Tries to find a constant with the name specified in the argument string:
+    #
+    #   "Module".constantize     # => Module
+    #   "Test::Unit".constantize # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter whether
+    # it starts with "::" or not. No lexical context is taken into account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C               # => 'inside'
+    #     "C".constantize # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check it it's owned
+          # directly before we reach Object or the end of ancestors.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+
+    # Tries to find a constant with the name specified in the argument string:
+    #
+    #   "Module".safe_constantize     # => Module
+    #   "Test::Unit".safe_constantize # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter whether
+    # it starts with "::" or not. No lexical context is taken into account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C                    # => 'inside'
+    #     "C".safe_constantize # => 'outside', same as ::C
+    #   end
+    #
+    # nil is returned when the name is not in CamelCase or the constant (or part of it) is
+    # unknown.
+    #
+    #   "blargle".safe_constantize  # => nil
+    #   "UnknownModule".safe_constantize  # => nil
+    #   "UnknownModule::Foo::Bar".safe_constantize  # => nil
+    #
+    def safe_constantize(camel_cased_word)
+      begin
+        constantize(camel_cased_word)
+      rescue NameError => e
+        raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
+          e.name.to_s == camel_cased_word.to_s
+      rescue ArgumentError => e
+        raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
+      end
+    end
+
+    # Returns the suffix that should be added to a number to denote the position
+    # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+    #
+    #   ordinal(1)     # => "st"
+    #   ordinal(2)     # => "nd"
+    #   ordinal(1002)  # => "nd"
+    #   ordinal(1003)  # => "rd"
+    #   ordinal(-11)   # => "th"
+    #   ordinal(-1021) # => "st"
+    def ordinal(number)
+      if (11..13).include?(number.to_i.abs % 100)
+        "th"
+      else
+        case number.to_i.abs % 10
+          when 1; "st"
+          when 2; "nd"
+          when 3; "rd"
+          else    "th"
+        end
+      end
+    end
+
+    # Turns a number into an ordinal string used to denote the position in an
+    # ordered sequence such as 1st, 2nd, 3rd, 4th.
+    #
+    #   ordinalize(1)     # => "1st"
+    #   ordinalize(2)     # => "2nd"
+    #   ordinalize(1002)  # => "1002nd"
+    #   ordinalize(1003)  # => "1003rd"
+    #   ordinalize(-11)   # => "-11th"
+    #   ordinalize(-1021) # => "-1021st"
+    def ordinalize(number)
+      "#{number}#{ordinal(number)}"
+    end
+
+    private
+
+    # Mount a regular expression that will match part by part of the constant.
+    # For instance, Foo::Bar::Baz will generate Foo(::Bar(::Baz)?)?
+    def const_regexp(camel_cased_word) #:nodoc:
+      parts = camel_cased_word.split("::")
+      last  = parts.pop
+
+      parts.reverse.inject(last) do |acc, part|
+        part.empty? ? acc : "#{part}(::#{acc})?"
+      end
+    end
+
+    # Applies inflection rules for +singularize+ and +pluralize+.
+    #
+    #  apply_inflections("post", inflections.plurals) # => "posts"
+    #  apply_inflections("posts", inflections.singulars) # => "post"
+    def apply_inflections(word, rules)
+      result = word.to_s.dup
+
+      if word.empty? || inflections.uncountables.include?(result.downcase[/\b\w+\Z/])
+        result
+      else
+        rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+        result
+      end
+    end
+  end
+end
+

data/motion_support.gemspec

@@ -16,4 +16,5 @@ Gem::Specification.new do |gem|
   gem.version       = MotionSupport::VERSION
 
   gem.add_dependency 'bubble-wrap'
+  gem.add_development_dependency 'motion-redgreen'
 end

data/spec/core_ext/array/prepend_append_spec.rb

@@ -0,0 +1,15 @@
+describe "Array" do
+
+  describe "#append" do
+    it "should prepend elements on the array" do
+      [1].append(2).should.equal([1,2])
+    end
+  end
+
+  describe "#prepend" do
+    it "should prepend elements on the array" do
+      [1].prepend(2).should.equal([2,1])
+    end
+  end
+
+end

data/spec/helpers/constantize_test_cases.rb

@@ -0,0 +1,76 @@
+#module Ace
+  #module Base
+    #class Case
+      #class Dice
+      #end
+    #end
+    #class Fase < Case
+    #end
+  #end
+  #class Gas
+    #include Base
+  #end
+#end
+
+#class Object
+  #module AddtlGlobalConstants
+    #class Case
+      #class Dice
+      #end
+    #end
+  #end
+  #include AddtlGlobalConstants
+#end
+
+#module ConstantizeTestCases
+  #def run_constantize_tests_on
+    #assert_nothing_raised { assert_equal Ace::Base::Case, yield("Ace::Base::Case") }
+    #assert_nothing_raised { assert_equal Ace::Base::Case, yield("::Ace::Base::Case") }
+    #assert_nothing_raised { assert_equal Ace::Base::Case::Dice, yield("Ace::Base::Case::Dice") }
+    #assert_nothing_raised { assert_equal Ace::Base::Fase::Dice, yield("Ace::Base::Fase::Dice") }
+    #assert_nothing_raised { assert_equal Ace::Gas::Case, yield("Ace::Gas::Case") }
+    #assert_nothing_raised { assert_equal Ace::Gas::Case::Dice, yield("Ace::Gas::Case::Dice") }
+    #assert_nothing_raised { assert_equal Case::Dice, yield("Case::Dice") }
+    #assert_nothing_raised { assert_equal Case::Dice, yield("Object::Case::Dice") }
+    #assert_nothing_raised { assert_equal ConstantizeTestCases, yield("ConstantizeTestCases") }
+    #assert_nothing_raised { assert_equal ConstantizeTestCases, yield("::ConstantizeTestCases") }
+    #assert_nothing_raised { assert_equal Object, yield("") }
+    #assert_nothing_raised { assert_equal Object, yield("::") }
+    #assert_raise(NameError) { yield("UnknownClass") }
+    #assert_raise(NameError) { yield("UnknownClass::Ace") }
+    #assert_raise(NameError) { yield("UnknownClass::Ace::Base") }
+    #assert_raise(NameError) { yield("An invalid string") }
+    #assert_raise(NameError) { yield("InvalidClass\n") }
+    #assert_raise(NameError) { yield("Ace::ConstantizeTestCases") }
+    #assert_raise(NameError) { yield("Ace::Base::ConstantizeTestCases") }
+    #assert_raise(NameError) { yield("Ace::Gas::Base") }
+    #assert_raise(NameError) { yield("Ace::Gas::ConstantizeTestCases") }
+  #end
+
+  #def run_safe_constantize_tests_on
+    #assert_nothing_raised { assert_equal Ace::Base::Case, yield("Ace::Base::Case") }
+    #assert_nothing_raised { assert_equal Ace::Base::Case, yield("::Ace::Base::Case") }
+    #assert_nothing_raised { assert_equal Ace::Base::Case::Dice, yield("Ace::Base::Case::Dice") }
+    #assert_nothing_raised { assert_equal Ace::Base::Fase::Dice, yield("Ace::Base::Fase::Dice") }
+    #assert_nothing_raised { assert_equal Ace::Gas::Case, yield("Ace::Gas::Case") }
+    #assert_nothing_raised { assert_equal Ace::Gas::Case::Dice, yield("Ace::Gas::Case::Dice") }
+    #assert_nothing_raised { assert_equal Case::Dice, yield("Case::Dice") }
+    #assert_nothing_raised { assert_equal Case::Dice, yield("Object::Case::Dice") }
+    #assert_nothing_raised { assert_equal ConstantizeTestCases, yield("ConstantizeTestCases") }
+    #assert_nothing_raised { assert_equal ConstantizeTestCases, yield("::ConstantizeTestCases") }
+    #assert_nothing_raised { assert_equal Object, yield("") }
+    #assert_nothing_raised { assert_equal Object, yield("::") }
+    #assert_nothing_raised { assert_equal nil, yield("UnknownClass") }
+    #assert_nothing_raised { assert_equal nil, yield("UnknownClass::Ace") }
+    #assert_nothing_raised { assert_equal nil, yield("UnknownClass::Ace::Base") }
+    #assert_nothing_raised { assert_equal nil, yield("An invalid string") }
+    #assert_nothing_raised { assert_equal nil, yield("InvalidClass\n") }
+    #assert_nothing_raised { assert_equal nil, yield("blargle") }
+    #assert_nothing_raised { assert_equal nil, yield("Ace::ConstantizeTestCases") }
+    #assert_nothing_raised { assert_equal nil, yield("Ace::Base::ConstantizeTestCases") }
+    #assert_nothing_raised { assert_equal nil, yield("Ace::Gas::Base") }
+    #assert_nothing_raised { assert_equal nil, yield("Ace::Gas::ConstantizeTestCases") }
+    #assert_nothing_raised { assert_equal nil, yield("#<Class:0x7b8b718b>::Nested_1") }
+  #end
+#end
+

data/spec/helpers/dup.rb

@@ -0,0 +1,13 @@
+## Dups the singleton and yields, restoring the original inflections later.
+## Use this in tests what modify the state of the singleton.
+##
+## This helper is implemented by setting @__instance__ because in some tests
+## there are module functions that access MotionSupport::Inflector.inflections,
+## so we need to replace the singleton itself.
+def with_dup(&block)
+  original = MotionSupport::Inflector.inflections
+  MotionSupport::Inflector::Inflections.instance_variable_set(:@__instance__, original.dup)
+  block.call
+  MotionSupport::Inflector::Inflections.instance_variable_set(:@__instance__, original)
+end
+

data/spec/helpers/inflector_test_cases.rb

@@ -0,0 +1,315 @@
+# encoding: utf-8
+
+module InflectorTestCases
+  SingularToPlural = {
+    "search"      => "searches",
+    "switch"      => "switches",
+    "fix"         => "fixes",
+    "box"         => "boxes",
+    "process"     => "processes",
+    "address"     => "addresses",
+    "case"        => "cases",
+    "stack"       => "stacks",
+    "wish"        => "wishes",
+    "fish"        => "fish",
+    "jeans"       => "jeans",
+    "funky jeans" => "funky jeans",
+    "my money"    => "my money",
+
+    "category"    => "categories",
+    "query"       => "queries",
+    "ability"     => "abilities",
+    "agency"      => "agencies",
+    "movie"       => "movies",
+
+    "archive"     => "archives",
+
+    "index"       => "indices",
+
+    "wife"        => "wives",
+    "safe"        => "saves",
+    "half"        => "halves",
+
+    "move"        => "moves",
+
+    "salesperson" => "salespeople",
+    "person"      => "people",
+
+    "spokesman"   => "spokesmen",
+    "man"         => "men",
+    "woman"       => "women",
+
+    "basis"       => "bases",
+    "diagnosis"   => "diagnoses",
+    "diagnosis_a" => "diagnosis_as",
+
+    "datum"       => "data",
+    "medium"      => "media",
+    "stadium"     => "stadia",
+    "analysis"    => "analyses",
+    "my_analysis" => "my_analyses",
+
+    "node_child"  => "node_children",
+    "child"       => "children",
+
+    "experience"  => "experiences",
+    "day"         => "days",
+
+    "comment"     => "comments",
+    "foobar"      => "foobars",
+    "newsletter"  => "newsletters",
+
+    "old_news"    => "old_news",
+    "news"        => "news",
+
+    "series"      => "series",
+    "species"     => "species",
+
+    "quiz"        => "quizzes",
+
+    "perspective" => "perspectives",
+
+    "ox"          => "oxen",
+    "photo"       => "photos",
+    "buffalo"     => "buffaloes",
+    "tomato"      => "tomatoes",
+    "dwarf"       => "dwarves",
+    "elf"         => "elves",
+    "information" => "information",
+    "equipment"   => "equipment",
+    "bus"         => "buses",
+    "status"      => "statuses",
+    "status_code" => "status_codes",
+    "mouse"       => "mice",
+
+    "louse"       => "lice",
+    "house"       => "houses",
+    "octopus"     => "octopi",
+    "virus"       => "viri",
+    "alias"       => "aliases",
+    "portfolio"   => "portfolios",
+
+    "vertex"      => "vertices",
+    "matrix"      => "matrices",
+    "matrix_fu"   => "matrix_fus",
+
+    "axis"        => "axes",
+    "taxi"        => "taxis", # prevents regression
+    "testis"      => "testes",
+    "crisis"      => "crises",
+
+    "rice"        => "rice",
+    "shoe"        => "shoes",
+
+    "horse"       => "horses",
+    "prize"       => "prizes",
+    "edge"        => "edges",
+
+    "cow"         => "kine",
+    "database"    => "databases",
+
+    # regression tests against improper inflection regexes
+    "|ice"        => "|ices",
+    "|ouse"       => "|ouses",
+    "slice"       => "slices",
+    "police"      => "police"
+  }
+
+  CamelToUnderscore = {
+    "Product"               => "product",
+    "SpecialGuest"          => "special_guest",
+    "ApplicationController" => "application_controller",
+    "Area51Controller"      => "area51_controller"
+  }
+
+  UnderscoreToLowerCamel = {
+    "product"                => "product",
+    "special_guest"          => "specialGuest",
+    "application_controller" => "applicationController",
+    "area51_controller"      => "area51Controller"
+  }
+
+  SymbolToLowerCamel = {
+    :product                => 'product',
+    :special_guest          => 'specialGuest',
+    :application_controller => 'applicationController',
+    :area51_controller      => 'area51Controller'
+  }
+
+  CamelToUnderscoreWithoutReverse = {
+    "HTMLTidy"              => "html_tidy",
+    "HTMLTidyGenerator"     => "html_tidy_generator",
+    "FreeBSD"               => "free_bsd",
+    "HTML"                  => "html",
+  }
+
+  CamelWithModuleToUnderscoreWithSlash = {
+    "Admin::Product" => "admin/product",
+    "Users::Commission::Department" => "users/commission/department",
+    "UsersSection::CommissionDepartment" => "users_section/commission_department",
+  }
+
+  ClassNameToForeignKeyWithUnderscore = {
+    "Person" => "person_id",
+    "MyApplication::Billing::Account" => "account_id"
+  }
+
+  ClassNameToForeignKeyWithoutUnderscore = {
+    "Person" => "personid",
+    "MyApplication::Billing::Account" => "accountid"
+  }
+
+  ClassNameToTableName = {
+    "PrimarySpokesman" => "primary_spokesmen",
+    "NodeChild"        => "node_children"
+  }
+
+  StringToParameterized = {
+    "Donald E. Knuth"                     => "donald-e-knuth",
+    "Random text with *(bad)* characters" => "random-text-with-bad-characters",
+    "Allow_Under_Scores"                  => "allow_under_scores",
+    "Trailing bad characters!@#"          => "trailing-bad-characters",
+    "!@#Leading bad characters"           => "leading-bad-characters",
+    "Squeeze   separators"                => "squeeze-separators",
+    "Test with + sign"                    => "test-with-sign",
+    "Test with malformed utf8 \251"       => "test-with-malformed-utf8"
+  }
+
+  StringToParameterizeWithNoSeparator = {
+    "Donald E. Knuth"                     => "donaldeknuth",
+    "With-some-dashes"                    => "with-some-dashes",
+    "Random text with *(bad)* characters" => "randomtextwithbadcharacters",
+    "Trailing bad characters!@#"          => "trailingbadcharacters",
+    "!@#Leading bad characters"           => "leadingbadcharacters",
+    "Squeeze   separators"                => "squeezeseparators",
+    "Test with + sign"                    => "testwithsign",
+    "Test with malformed utf8 \251"       => "testwithmalformedutf8"
+  }
+
+  StringToParameterizeWithUnderscore = {
+    "Donald E. Knuth"                     => "donald_e_knuth",
+    "Random text with *(bad)* characters" => "random_text_with_bad_characters",
+    "With-some-dashes"                    => "with-some-dashes",
+    "Retain_underscore"                   => "retain_underscore",
+    "Trailing bad characters!@#"          => "trailing_bad_characters",
+    "!@#Leading bad characters"           => "leading_bad_characters",
+    "Squeeze   separators"                => "squeeze_separators",
+    "Test with + sign"                    => "test_with_sign",
+    "Test with malformed utf8 \251"       => "test_with_malformed_utf8"
+  }
+
+  StringToParameterizedAndNormalized = {
+    "Malmö"                               => "malmo",
+    "Garçons"                             => "garcons",
+    "Ops\331"                             => "opsu",
+    "Ærøskøbing"                          => "aeroskobing",
+    "Aßlar"                               => "asslar",
+    "Japanese: 日本語"                    => "japanese"
+  }
+
+  UnderscoreToHuman = {
+    "employee_salary" => "Employee salary",
+    "employee_id"     => "Employee",
+    "underground"     => "Underground"
+  }
+
+  MixtureToTitleCase = {
+    'active_record'         => 'Active Record',
+    'ActiveRecord'          => 'Active Record',
+    'action web service'    => 'Action Web Service',
+    'Action Web Service'    => 'Action Web Service',
+    'Action web service'    => 'Action Web Service',
+    'actionwebservice'      => 'Actionwebservice',
+    'Actionwebservice'      => 'Actionwebservice',
+    "david's code"          => "David's Code",
+    "David's code"          => "David's Code",
+    "david's Code"          => "David's Code",
+    "sgt. pepper's"         => "Sgt. Pepper's",
+    "i've just seen a face" => "I've Just Seen A Face",
+    "maybe you'll be there" => "Maybe You'll Be There",
+    "¿por qué?"             => '¿Por Qué?',
+    "Fred’s"                => "Fred’s",
+    "Fred`s"                => "Fred`s"
+  }
+
+  OrdinalNumbers = {
+    "-1" => "-1st",
+    "-2" => "-2nd",
+    "-3" => "-3rd",
+    "-4" => "-4th",
+    "-5" => "-5th",
+    "-6" => "-6th",
+    "-7" => "-7th",
+    "-8" => "-8th",
+    "-9" => "-9th",
+    "-10" => "-10th",
+    "-11" => "-11th",
+    "-12" => "-12th",
+    "-13" => "-13th",
+    "-14" => "-14th",
+    "-20" => "-20th",
+    "-21" => "-21st",
+    "-22" => "-22nd",
+    "-23" => "-23rd",
+    "-24" => "-24th",
+    "-100" => "-100th",
+    "-101" => "-101st",
+    "-102" => "-102nd",
+    "-103" => "-103rd",
+    "-104" => "-104th",
+    "-110" => "-110th",
+    "-111" => "-111th",
+    "-112" => "-112th",
+    "-113" => "-113th",
+    "-1000" => "-1000th",
+    "-1001" => "-1001st",
+    "0" => "0th",
+    "1" => "1st",
+    "2" => "2nd",
+    "3" => "3rd",
+    "4" => "4th",
+    "5" => "5th",
+    "6" => "6th",
+    "7" => "7th",
+    "8" => "8th",
+    "9" => "9th",
+    "10" => "10th",
+    "11" => "11th",
+    "12" => "12th",
+    "13" => "13th",
+    "14" => "14th",
+    "20" => "20th",
+    "21" => "21st",
+    "22" => "22nd",
+    "23" => "23rd",
+    "24" => "24th",
+    "100" => "100th",
+    "101" => "101st",
+    "102" => "102nd",
+    "103" => "103rd",
+    "104" => "104th",
+    "110" => "110th",
+    "111" => "111th",
+    "112" => "112th",
+    "113" => "113th",
+    "1000" => "1000th",
+    "1001" => "1001st"
+  }
+
+  UnderscoresToDashes = {
+    "street"                => "street",
+    "street_address"        => "street-address",
+    "person_street_address" => "person-street-address"
+  }
+
+  Irregularities = {
+    'person' => 'people',
+    'man'    => 'men',
+    'child'  => 'children',
+    'sex'    => 'sexes',
+    'move'   => 'moves',
+    'cow'    => 'kine',
+    'zombie' => 'zombies',
+  }
+end
+