swiss_db 0.6.8 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2313d48751d8db38ddeb8d6b35b77505b81f0e19
-  data.tar.gz: 8b913b2cd08f1cbd529409c30babbc2d2e5f298d
+  metadata.gz: 04bd172ce896a99dd76a23f2670409210a16cbd3
+  data.tar.gz: 234b633535968c2761a3cba2bc056cec691716d9
 SHA512:
-  metadata.gz: 531bd255a92c5b20754354c5ddc8982bbfd717af76f0a905b6eefd79e4b78064793ca5ff25746ea422dd73371aa1d7c4f71edcbdc3e2e48a888d0318da5f4833
-  data.tar.gz: dcde38e09562c53dea3404e1f5db68d967232910f6cf8e67975fedc4b3116242a2d224fe83c22ee1b585fc4be81be4aa34ffe249ffaa73cf3cf91a7a3f6deab4
+  metadata.gz: 8a780767d3fed17e7b36f145a678584e48b7d835c799a9af4732d5cf8ec5ce2d7f17cae428b824b713816209f8746980414791a75e64f736f63125b4db85911a
+  data.tar.gz: cfa8a60bd0dfd045bc8f46823e2373afee309b59734fbe4f26a93ea7c6bf22c30b0930304ff6ca7b7d934d0e90a9f1b7340886acc452404b5f2e37d0d1106836

data/README.md

@@ -105,6 +105,9 @@ KNOWN LIMITATION: This ORM compiles in the database name and the database versio
    DataStore.drop_db #=> true if the DB was dropped, false if not
 ```
 
+## Contributors
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/lib/motion-support/default_inflections.rb

@@ -0,0 +1,69 @@
+#--
+# Defines the standard inflection rules. These are the starting point for
+# new projects and are not considered complete. The current set of inflection
+# rules is frozen. This means, we do not change them to become more complete.
+# This is a safety measure to keep existing applications from breaking.
+#++
+module MotionSupport
+  Inflector.inflections do |inflect|
+    inflect.plural(/$/, 's')
+    inflect.plural(/s$/i, 's')
+    inflect.plural(/^(ax|test)is$/i, '\1es')
+    inflect.plural(/(octop|vir)us$/i, '\1i')
+    inflect.plural(/(octop|vir)i$/i, '\1i')
+    inflect.plural(/(alias|status)$/i, '\1es')
+    inflect.plural(/(bu)s$/i, '\1ses')
+    inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+    inflect.plural(/([ti])um$/i, '\1a')
+    inflect.plural(/([ti])a$/i, '\1a')
+    inflect.plural(/sis$/i, 'ses')
+    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    inflect.plural(/(hive)$/i, '\1s')
+    inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+    inflect.plural(/^(m|l)ouse$/i, '\1ice')
+    inflect.plural(/^(m|l)ice$/i, '\1ice')
+    inflect.plural(/^(ox)$/i, '\1en')
+    inflect.plural(/^(oxen)$/i, '\1')
+    inflect.plural(/(quiz)$/i, '\1zes')
+
+    inflect.singular(/s$/i, '')
+    inflect.singular(/(ss)$/i, '\1')
+    inflect.singular(/(n)ews$/i, '\1ews')
+    inflect.singular(/([ti])a$/i, '\1um')
+    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+    inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
+    inflect.singular(/([^f])ves$/i, '\1fe')
+    inflect.singular(/(hive)s$/i, '\1')
+    inflect.singular(/(tive)s$/i, '\1')
+    inflect.singular(/([lr])ves$/i, '\1f')
+    inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    inflect.singular(/(s)eries$/i, '\1eries')
+    inflect.singular(/(m)ovies$/i, '\1ovie')
+    inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+    inflect.singular(/^(m|l)ice$/i, '\1ouse')
+    inflect.singular(/(bus)(es)?$/i, '\1')
+    inflect.singular(/(o)es$/i, '\1')
+    inflect.singular(/(shoe)s$/i, '\1')
+    inflect.singular(/(cris|test)(is|es)$/i, '\1is')
+    inflect.singular(/^(a)x[ie]s$/i, '\1xis')
+    inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
+    inflect.singular(/(alias|status)(es)?$/i, '\1')
+    inflect.singular(/^(ox)en/i, '\1')
+    inflect.singular(/(vert|ind)ices$/i, '\1ex')
+    inflect.singular(/(matr)ices$/i, '\1ix')
+    inflect.singular(/(quiz)zes$/i, '\1')
+    inflect.singular(/(database)s$/i, '\1')
+
+    inflect.irregular('person', 'people')
+    inflect.irregular('man', 'men')
+    inflect.irregular('child', 'children')
+    inflect.irregular('sex', 'sexes')
+    inflect.irregular('move', 'moves')
+    inflect.irregular('zombie', 'zombies')
+
+    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans police))
+
+  end
+end

data/lib/motion-support/{inflections.rb → inflector/inflections.rb}

@@ -158,18 +158,31 @@ module MotionSupport
             singular(/(#{s0})#{srest}$/i, '\1' + srest)
             singular(/(#{p0})#{prest}$/i, '\1' + srest)
           else
-            plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
-            plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
-            plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
-            plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
-
-            singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
-            singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
-            singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
-            singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+            # define_plurals and define_singulars arose from a strange error where
+            # the app would quit with absolutely no output (not even VM Aborting!).
+            # The only way to turn off the error was to comment out some lines, but
+            # it didn't really matter which ones, as long as you commented out 4 or 5.
+            # So I split them out like this on a whim and it seems to have solved the problem.
+            # Weird!!
+            define_plurals(s0, srest, p0, prest)
+            define_singulars(s0, srest, p0, prest)
           end
         end
 
+        def define_plurals(s0, srest, p0, prest)
+          plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
+          plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
+          plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
+          plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
+        end
+
+        def define_singulars(s0, srest, p0, prest)
+          singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
+          singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
+          singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
+          singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+        end
+
         # Add uncountable words that shouldn't be attempted inflected.
         #
         #   uncountable 'money'

data/lib/motion-support/string.rb

@@ -175,4 +175,4 @@ class String
   def foreign_key(separate_class_name_and_id_with_underscore = true)
     MotionSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
   end
-end
+end

data/lib/swiss_db/cursor.rb

@@ -20,11 +20,11 @@ end
 
 class Cursor # < Array
 
-  FIELD_TYPE_BLOB = 4
-  FIELD_TYPE_FLOAT = 2
+  FIELD_TYPE_BLOB    = 4
+  FIELD_TYPE_FLOAT   = 2
   FIELD_TYPE_INTEGER = 1
-  FIELD_TYPE_NULL = 0
-  FIELD_TYPE_STRING = 3
+  FIELD_TYPE_NULL    = 0
+  FIELD_TYPE_STRING  = 3
 
   attr_accessor :cursor, :model
 
@@ -52,7 +52,7 @@ class Cursor # < Array
       # puts i
       hash_obj = {}
       cursor.moveToPosition(i)
-      $current_schema[model.class_name].each do |k, v|
+      $current_schema[model.table_name].each do |k, v|
         hash_obj[k.to_sym] = self.send(k.to_sym)
       end
       arr << CursorModel.new(hash_obj)
@@ -60,33 +60,55 @@ class Cursor # < Array
     arr
   end
 
-  def count
-    cursor.getCount
+  def method_missing(methId, *args)
+    method_name = methId.id2name
+
+    if valid_setter_getter?(method_name)
+      handle_get_or_set(method_name, args)
+    else
+      super
+    end
   end
 
-  def method_missing(methId, *args)
-    str = methId.id2name
-    if args.count == 0
-      index = cursor.getColumnIndex(str)
-      type = cursor.getType(index)
-      # puts "getting field #{str} at index #{index} of type #{type}"
-      if type == FIELD_TYPE_STRING
-        cursor.getString(index)
-      elsif type == FIELD_TYPE_INTEGER
-        cursor.getInt(index)
-      elsif type == FIELD_TYPE_NULL
-        nil #??
-      elsif type == FIELD_TYPE_FLOAT
-        cursor.getFloat(index)
-      elsif type == FIELD_TYPE_BLOB
-        cursor.getBlob(index)
-      end
-    elsif args.count == 1
-      # assignment... add to values to save
-      @values[str.gsub!("=", "")] = args[0]
+  def valid_setter_getter?(method_name)
+    method_name.chop! if is_setter? method_name
+    column_names.include? method_name
+  end
+
+  def handle_get_or_set(method_name, args)
+    if is_setter? method_name
+      set_method(args)
+    else
+      get_method(method_name)
+    end
+  end
+
+  def is_setter?(method_name)
+    method_name[-1] == '='
+  end
+
+  def get_method(method_name)
+    index = cursor.getColumnIndex(method_name)
+    type = cursor.getType(index)
+    # puts "getting field #{method_name} at index #{index} of type #{type}"
+
+    if type == FIELD_TYPE_STRING
+      cursor.getString(index)
+    elsif type == FIELD_TYPE_INTEGER
+      cursor.getInt(index)
+    elsif type == FIELD_TYPE_NULL
+      nil #??
+    elsif type == FIELD_TYPE_FLOAT
+      cursor.getFloat(index)
+    elsif type == FIELD_TYPE_BLOB
+      cursor.getBlob(index)
     end
   end
 
+  def set_method(method_name, args)
+    @values[method_name.chop] = args[0]
+  end
+
   def save
     primary_key = model.primary_key
     pk_value = self.send(primary_key.to_sym)
@@ -100,5 +122,11 @@ class Cursor # < Array
     model.store.update(model.table_name, {key => value}, {primary_key => pk_value})
   end
 
+  def count
+    cursor.getCount
+  end
 
-end
+  def column_names
+    cursor.getColumnNames
+  end
+end

data/lib/swiss_db/db.rb

@@ -30,7 +30,8 @@ class Object
     puts @current_schema.inspect
   end
 
-  def entity(table_name, &block)
+  def entity(class_name, &block)
+    table_name = class_name.tableize
     puts "adding entity #{table_name} to schema"
     @table_name = table_name
     @current_schema[@table_name] = {}
@@ -43,8 +44,10 @@ class Object
     @current_schema[@table_name][name] = type
   end
 
-  def boolean(column_name)
-    add_column column_name.to_s, "BOOLEAN"
+  %w(boolean float double integer datetime).each do |type|
+    define_method(type) do |column_name|
+      add_column column_name.to_s, type.upcase
+    end
   end
 
   def string(column_name)
@@ -55,8 +58,4 @@ class Object
     add_column column_name.to_s, "INTEGER"
   end
 
-  def double(column_name)
-    add_column column_name.to_s, "DOUBLE"
-  end
-
 end

data/lib/swiss_db.rb

@@ -14,7 +14,7 @@ if defined?(Motion) && defined?(Motion::Project::Config)
     insert_point = app.files.find_index { |file| file =~ /^(?:\.\/)?app\// } || 0
 
     # change to "swiss_db" for just swiss_db
-    Dir.glob(File.join(lib_dir_path, "**/*.rb")).reverse.each do |file|
+    Dir.glob(File.join(lib_dir_path, "**/*.rb")).each do |file|
       app.files.insert(insert_point, file)
     end
 
@@ -25,4 +25,3 @@ if defined?(Motion) && defined?(Motion::Project::Config)
 
   end
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swiss_db
 version: !ruby/object:Gem::Version
-  version: 0.6.8
+  version: 0.7.0
 platform: ruby
 authors:
 - Jonathan Silverman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-12 00:00:00.000000000 Z
+date: 2015-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -47,9 +47,9 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/motion-support/array.rb
-- lib/motion-support/inflections.rb
-- lib/motion-support/inflector.rb
-- lib/motion-support/methods.rb
+- lib/motion-support/default_inflections.rb
+- lib/motion-support/inflector/inflections.rb
+- lib/motion-support/inflector/methods.rb
 - lib/motion-support/string.rb
 - lib/swiss_db.rb
 - lib/swiss_db/cursor.rb

data/lib/motion-support/inflector.rb

@@ -1,322 +0,0 @@
-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.
-  module Inflector
-    class << 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]*/) { |match| inflections.acronyms[match] || match.capitalize }
-        else
-          string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.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.gsub!("-", "_")
-        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'.humanize # => "Employee salary"
-      #   'author_id'.humanize       # => "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.gsub!('_', ' ')
-        result.gsub(/([a-z\d]*)/i) { |match|
-          "#{inflections.acronyms[match] || match.downcase}"
-        }.gsub(/^\w/) { |match| match.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]/) { |match| match.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.gsub('_', '-')
-      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)
-        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
-
-      # 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)
-        abs_number = number.to_i.abs
-
-        if (11..13).include?(abs_number % 100)
-          "th"
-        else
-          case abs_number % 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
-end