opal-factory_girl 4.5.0.3

data/factory_girl/lib/factory_girl/syntax.rb

@@ -0,0 +1,7 @@
+require 'factory_girl/syntax/methods'
+require 'factory_girl/syntax/default'
+
+module FactoryGirl
+  module Syntax
+  end
+end

data/factory_girl/lib/factory_girl/syntax/default.rb

@@ -0,0 +1,76 @@
+module FactoryGirl
+  module Syntax
+    module Default
+      include Methods
+
+      def define(&block)
+        DSL.run(block)
+      end
+
+      def modify(&block)
+        ModifyDSL.run(block)
+      end
+
+      class DSL
+        def factory(name, options = {}, &block)
+          factory = Factory.new(name, options)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition)
+          proxy.instance_eval(&block) if block_given?
+
+          FactoryGirl.register_factory(factory)
+
+          proxy.child_factories.each do |(child_name, child_options, child_block)|
+            parent_factory = child_options.delete(:parent) || name
+            factory(child_name, child_options.merge(parent: parent_factory), &child_block)
+          end
+        end
+
+        def sequence(name, *args, &block)
+          FactoryGirl.register_sequence(Sequence.new(name, *args, &block))
+        end
+
+        def trait(name, &block)
+          FactoryGirl.register_trait(Trait.new(name, &block))
+        end
+
+        def to_create(&block)
+          FactoryGirl.to_create(&block)
+        end
+
+        def skip_create
+          FactoryGirl.skip_create
+        end
+
+        def initialize_with(&block)
+          FactoryGirl.initialize_with(&block)
+        end
+
+        def self.run(block)
+          new.instance_eval(&block)
+        end
+
+        delegate :before, :after, :callback, to: :configuration
+
+        private
+
+        def configuration
+          FactoryGirl.configuration
+        end
+      end
+
+      class ModifyDSL
+        def factory(name, options = {}, &block)
+          factory = FactoryGirl.factory_by_name(name)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition.overridable)
+          proxy.instance_eval(&block)
+        end
+
+        def self.run(block)
+          new.instance_eval(&block)
+        end
+      end
+    end
+  end
+
+  extend Syntax::Default
+end

data/factory_girl/lib/factory_girl/syntax/methods.rb

@@ -0,0 +1,95 @@
+module FactoryGirl
+  module Syntax
+    ## This module is a container for all strategy methods provided by
+    ## FactoryGirl. This includes all the default strategies provided ({Methods#build},
+    ## {Methods#create}, {Methods#build_stubbed}, and {Methods#attributes_for}), as well as
+    ## the complementary *_list methods.
+    ## @example singular factory execution
+    ##   # basic use case
+    ##   build(:completed_order)
+    ##
+    ##   # factory yielding its result to a block
+    ##   create(:post) do |post|
+    ##     create(:comment, post: post)
+    ##   end
+    ##
+    ##   # factory with attribute override
+    ##   attributes_for(:post, title: "I love Ruby!")
+    ##
+    ##   # factory with traits and attribute override
+    ##   build_stubbed(:user, :admin, :male, name: "John Doe")
+    ##
+    ## @example multiple factory execution
+    ##   # basic use case
+    ##   build_list(:completed_order, 2)
+    ##   create_list(:completed_order, 2)
+    ##
+    ##   # factory with attribute override
+    ##   attributes_for_list(:post, 4, title: "I love Ruby!")
+    ##
+    ##   # factory with traits and attribute override
+    ##   build_stubbed_list(:user, 15, :admin, :male, name: "John Doe")
+    module Methods
+      # @!parse FactoryGirl.register_default_strategies
+      # @!method build(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Builds a registered factory by name.
+      # @return [Object] instantiated object defined by the factory
+
+      # @!method create(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Creates a registered factory by name.
+      # @return [Object] instantiated object defined by the factory
+
+      # @!method build_stubbed(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Builds a stubbed registered factory by name.
+      # @return [Object] instantiated object defined by the factory
+
+      # @!method attributes_for(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Generates a hash of attributes for a registered factory by name.
+      # @return [Hash] hash of attributes for the factory
+
+      # @!method build_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array] array of built objects defined by the factory
+
+      # @!method create_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array] array of created objects defined by the factory
+
+      # @!method build_stubbed_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array] array of stubbed objects defined by the factory
+
+      # @!method attributes_for_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array<Hash>] array of attribute hashes for the factory
+
+      # @!method strategy_method
+      # @!visibility private
+      # @param [Symbol] name name of the factory to build
+      # @param [Array<Symbol, Symbol, Hash>] traits_and_overrides splat args traits and a hash of overrides
+      # @param [Proc] block block to be executed
+
+      # @!method strategy_method_list
+      # @!visibility private
+      # @param [Symbol] name name of the factory to execute
+      # @param [Integer] amount the number of instances to execute
+      # @param [Array<Symbol, Symbol, Hash>] traits_and_overrides splat args traits and a hash of overrides
+
+      # Generates and returns the next value in a sequence.
+      #
+      # Arguments:
+      #   name: (Symbol)
+      #     The name of the sequence that a value should be generated for.
+      #
+      # Returns:
+      #   The next value in the sequence. (Object)
+      def generate(name)
+        FactoryGirl.sequence_by_name(name).next
+      end
+    end
+  end
+end

data/factory_girl/lib/factory_girl/syntax_runner.rb

@@ -0,0 +1,6 @@
+module FactoryGirl
+  # @api private
+  class SyntaxRunner
+    include Syntax::Methods
+  end
+end

data/factory_girl/lib/factory_girl/trait.rb

@@ -0,0 +1,30 @@
+module FactoryGirl
+  # @api private
+  class Trait
+    attr_reader :name, :definition
+
+    def initialize(name, &block)
+      @name = name
+      @block = block
+      @definition = Definition.new(@name)
+
+      proxy = FactoryGirl::DefinitionProxy.new(@definition)
+      proxy.instance_eval(&@block) if block_given?
+    end
+
+    delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
+             :callbacks, :attributes, to: :@definition
+
+    def names
+      [@name]
+    end
+
+    def ==(other)
+      name == other.name &&
+        block == other.block
+    end
+
+    protected
+    attr_reader :block
+  end
+end

data/factory_girl/lib/factory_girl/version.rb

@@ -0,0 +1,3 @@
+module FactoryGirl
+  VERSION = '4.5.0'
+end

data/lib/opal-factory_girl.rb

@@ -0,0 +1,16 @@
+[
+    'jruby/synchronized',
+    'monitor',
+    'thread_safe/jruby_cache_backend',
+    'atomic',
+    'jruby',
+    'logger',
+    'active_support/inflector/methods', # has an incompatible regex in it
+].each { |r| Opal::Processor.stub_file r }
+
+
+# Just register our opal code path with opal build tools
+Opal.append_path File.expand_path('../../opal', __FILE__)
+Opal.append_path File.expand_path('../../factory_girl/lib', __FILE__)
+require 'opal-activesupport'
+Opal.use_gem 'activesupport'

data/lib/opal/factory_girl/version.rb

@@ -0,0 +1,8 @@
+require 'factory_girl/version'
+
+module Opal
+  module FactoryGirl
+    # Add a minor version to the end in case there are opal specific issues to fix
+    VERSION = "#{::FactoryGirl::VERSION}.3"
+  end
+end

data/opal/opal-factory_girl.rb

@@ -0,0 +1,184 @@
+module Mutex_m
+  def synchronize
+    yield
+  end
+end
+
+require 'active_support/core_ext/module/delegation'
+require 'active_support/inflector'
+require 'opal/active_support/inflector/methods'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string'
+require 'active_support/notifications/fanout'
+
+class String
+  def humanize
+    ActiveSupport::Inflector.humanize(self)
+  end
+end
+
+class ActiveSupport::Inflector::Inflections
+  def humans
+    @humans ||= []
+  end
+
+  def acronyms
+    @acronyms ||= {}
+  end
+
+  def acronym_regex
+    @acronym_regex ||= /(?=a)b/
+  end
+
+  def human(rule, replacement)
+    @humans.prepend([rule, replacement])
+  end
+
+  def acronym(word)
+    a = acronyms
+    _ = acronym_regex
+    a[word.downcase] = word
+    @acronym_regex = /#{a.values.join("|")}/
+  end
+end
+
+module ActiveSupport
+  module Notifications
+    # This is a default queue implementation that ships with Notifications.
+    # It just pushes events to all registered log subscribers.
+    #
+    # This class is thread safe. All methods are reentrant.
+    class Fanout
+      #def subscribe(pattern = nil, block = Proc.new)
+      # Opal doesn't like block without &block and Proc.new isn't valid anyways
+      def subscribe(pattern = nil, &block)
+        subscriber = Subscribers.new pattern, block
+        synchronize do
+          @subscribers << subscriber
+          @listeners_for.clear
+        end
+        subscriber
+      end
+    end
+  end
+end
+
+require 'factory_girl'
+
+# Opal didn't seem like like synchronize { super }, so removed sync, probably super w/ args inside a block
+module ThreadSafe
+  class SynchronizedCacheBackend
+    def [](key)
+      super
+    end
+
+    def []=(key, value)
+      super
+    end
+
+    def compute_if_absent(key)
+      super
+    end
+
+    def compute_if_present(key)
+      super
+    end
+
+    def compute(key)
+      super
+    end
+
+    def merge_pair(key, value)
+      super
+    end
+
+    def replace_pair(key, old_value, new_value)
+      super
+    end
+
+    def replace_if_exists(key, new_value)
+      super
+    end
+
+    def get_and_set(key, value)
+      super
+    end
+
+    def key?(key)
+      super
+    end
+
+    def value?(value)
+      super
+    end
+
+    def delete(key)
+      super
+    end
+
+    def delete_pair(key, value)
+      super
+    end
+
+    def clear
+      super
+    end
+
+    def size
+      super
+    end
+
+    def get_or_default(key, default_value)
+      super
+    end
+
+    private
+    def dupped_backend
+      super
+    end
+  end
+end
+
+module FactoryGirl
+  class Decorator
+    class NewConstructor < Decorator
+      def build_class_accessor
+        @build_class
+      end
+
+      # For some reason, the instance_variable_get was not working
+      #delegate :new, to: :@build_class
+      delegate :new, to: :build_class_accessor
+    end
+  end
+end
+
+
+module FactoryGirl
+  class AttributeAssigner
+    def instance_builder_set(&instance_builder)
+      @instance_builder = instance_builder
+    end
+  end
+
+  # @api private
+  class Factory
+    def run(build_strategy, overrides, &block)
+      block ||= ->(result) { result }
+      compile
+
+      strategy = StrategyCalculator.new(build_strategy).strategy.new
+
+      evaluator = evaluator_class.new(strategy, overrides.symbolize_keys)
+      constr = compiled_constructor
+      attribute_assigner = AttributeAssigner.new(evaluator, build_class, &constr)
+      # Opal issues with passing a block reference in a constructor
+      attribute_assigner.instance_builder_set(&constr)
+
+      evaluation = Evaluation.new(attribute_assigner, compiled_to_create)
+      evaluation.add_observer(CallbacksObserver.new(callbacks, evaluator))
+
+      strategy.result(evaluation).tap(&block)
+    end
+  end
+end

data/opal/opal/active_support/inflector/methods.rb

@@ -0,0 +1,395 @@
+require 'active_support/inflections'
+
+module ActiveSupport
+  # 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 or wish to define rules for languages other
+  # than English, please correct or add them yourself (explained below).
+  module Inflector
+    extend self
+
+    # Returns the plural form of the word in the string.
+    #
+    # If passed an optional +locale+ parameter, the word will be
+    # pluralized using rules defined for that language. By default,
+    # this parameter is set to <tt>:en</tt>.
+    #
+    #   pluralize('post')             # => "posts"
+    #   pluralize('octopus')          # => "octopi"
+    #   pluralize('sheep')            # => "sheep"
+    #   pluralize('words')            # => "words"
+    #   pluralize('CamelOctopus')     # => "CamelOctopi"
+    #   pluralize('ley', :es)         # => "leyes"
+    def pluralize(word, locale = :en)
+      apply_inflections(word, inflections(locale).plurals)
+    end
+
+    # The reverse of #pluralize, returns the singular form of a word in a
+    # string.
+    #
+    # If passed an optional +locale+ parameter, the word will be
+    # singularized using rules defined for that language. By default,
+    # this parameter is set to <tt>:en</tt>.
+    #
+    #   singularize('posts')            # => "post"
+    #   singularize('octopi')           # => "octopus"
+    #   singularize('sheep')            # => "sheep"
+    #   singularize('word')             # => "word"
+    #   singularize('CamelOctopi')      # => "CamelOctopus"
+    #   singularize('leyes', :es)       # => "ley"
+    def singularize(word, locale = :en)
+      apply_inflections(word, inflections(locale).singulars)
+    end
+
+    # Converts strings to UpperCamelCase.
+    # If the +uppercase_first_letter+ parameter is set to false, then produces
+    # lowerCamelCase.
+    #
+    # Also converts '/' to '::' which is useful for converting
+    # paths to namespaces.
+    #
+    #   camelize('active_model')                # => "ActiveModel"
+    #   camelize('active_model', false)         # => "activeModel"
+    #   camelize('active_model/errors')         # => "ActiveModel::Errors"
+    #   camelize('active_model/errors', false)  # => "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:
+    #
+    #   camelize(underscore('SSLError'))        # => "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}" }
+      string.gsub!('/'.freeze, '::'.freeze)
+      string
+    end
+
+    # Makes an underscored, lowercase form from the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    #   underscore('ActiveModel')         # => "active_model"
+    #   underscore('ActiveModel::Errors') # => "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:
+    #
+    #   camelize(underscore('SSLError'))  # => "SslError"
+    def underscore(camel_cased_word)
+      return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+      word = camel_cased_word.to_s.gsub('::'.freeze, '/'.freeze)
+      word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+      word.tr!("-".freeze, "_".freeze)
+      word.downcase!
+      word
+    end
+
+    # Tweaks an attribute name for display to end users.
+    #
+    # Specifically, performs these transformations:
+    #
+    # * Applies human inflection rules to the argument.
+    # * Deletes leading underscores, if any.
+    # * Removes a "_id" suffix if present.
+    # * Replaces underscores with spaces, if any.
+    # * Downcases all words except acronyms.
+    # * Capitalizes the first word.
+    #
+    # The capitalization of the first word can be turned off by setting the
+    # +:capitalize+ option to false (default is true).
+    #
+    #   humanize('employee_salary')              # => "Employee salary"
+    #   humanize('author_id')                    # => "Author"
+    #   humanize('author_id', capitalize: false) # => "author"
+    #   humanize('_id')                          # => "Id"
+    #
+    # If "SSL" was defined to be an acronym:
+    #
+    #   humanize('ssl_error') # => "SSL error"
+    #
+    def humanize(lower_case_and_underscored_word, options = {})
+      result = lower_case_and_underscored_word.to_s.dup
+
+      # no humans attr exists on inflections, need to port that over
+
+      # opal - string mutation
+      inflections.humans.each { |(rule, replacement)| break if (result = result.sub(rule, replacement)) }
+
+      # opal - \A and \z not supported
+      #result = result.sub(/\A_+/, ''.freeze)
+      result = result.sub(/^_+/, ''.freeze)
+      #result = result.sub(/_id\z/, ''.freeze)
+      result = result.sub(/_id$/, ''.freeze)
+      result = result.tr('_'.freeze, ' '.freeze)
+
+      result = result.gsub(/([a-z\d]*)/i) do |match|
+        "#{inflections.acronyms[match] || match.downcase}"
+      end
+
+      if options.fetch(:capitalize, true)
+        #result = result.sub(/\A\w/) { |match| match.upcase }
+        result = result.sub(/^\w/) { |match| match.upcase }
+      end
+
+      result
+    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+.
+    #
+    #   titleize('man from the boondocks')   # => "Man From The Boondocks"
+    #   titleize('x-men: the last stand')    # => "X Men: The Last Stand"
+    #   titleize('TheManWithoutAPast')       # => "The Man Without A Past"
+    #   titleize('raiders_of_the_lost_ark')  # => "Raiders Of The Lost Ark"
+    def titleize(word)
+      # negative lookbehind doesn't work in Firefox / Safari
+      # humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { |match| match.capitalize }
+      humanized = humanize(underscore(word))
+      humanized.reverse.gsub(/[a-z](?!['’`])\b/) { |match| match.capitalize }.reverse
+    end
+
+    # Creates 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.
+    #
+    #   tableize('RawScaledScorer') # => "raw_scaled_scorers"
+    #   tableize('ham_and_egg')     # => "ham_and_eggs"
+    #   tableize('fancyCategory')   # => "fancy_categories"
+    def tableize(class_name)
+      pluralize(underscore(class_name))
+    end
+
+    # Creates 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).
+    #
+    #   classify('ham_and_eggs') # => "HamAndEgg"
+    #   classify('posts')        # => "Post"
+    #
+    # Singular names are not handled correctly:
+    #
+    #   classify('calculus')     # => "Calculu"
+    def classify(table_name)
+      # strip out any leading schema name
+      camelize(singularize(table_name.to_s.sub(/.*\./, ''.freeze)))
+    end
+
+    # Replaces underscores with dashes in the string.
+    #
+    #   dasherize('puni_puni') # => "puni-puni"
+    def dasherize(underscored_word)
+      underscored_word.tr('_'.freeze, '-'.freeze)
+    end
+
+    # Removes the module part from the expression in the string.
+    #
+    #   demodulize('ActiveRecord::CoreExtensions::String::Inflections') # => "Inflections"
+    #   demodulize('Inflections')                                       # => "Inflections"
+    #   demodulize('::Inflections')                                     # => "Inflections"
+    #   demodulize('')                                                  # => ""
+    #
+    # 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.
+    #
+    #   deconstantize('Net::HTTP')   # => "Net"
+    #   deconstantize('::Net::HTTP') # => "::Net"
+    #   deconstantize('String')      # => ""
+    #   deconstantize('::String')    # => ""
+    #   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'.
+    #
+    #   foreign_key('Message')        # => "message_id"
+    #   foreign_key('Message', false) # => "messageid"
+    #   foreign_key('Admin::Post')    # => "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
+    #   'Foo::Bar'.constantize # => Foo::Bar
+    #
+    # 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('::'.freeze)
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && 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 if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          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.
+    #
+    #   safe_constantize('Module')   # => Module
+    #   safe_constantize('Foo::Bar') # => Foo::Bar
+    #
+    # 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'
+    #     safe_constantize('C') # => 'outside', same as ::C
+    #   end
+    #
+    # +nil+ is returned when the name is not in CamelCase or the constant (or
+    # part of it) is unknown.
+    #
+    #   safe_constantize('blargle')                  # => nil
+    #   safe_constantize('UnknownModule')            # => nil
+    #   safe_constantize('UnknownModule::Foo::Bar')  # => nil
+    def safe_constantize(camel_cased_word)
+      constantize(camel_cased_word)
+    rescue NameError => e
+      raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+          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
+
+    # Mounts a regular expression, returned as a string to ease interpolation,
+    # that will match part by part the given constant.
+    #
+    #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
+    #   const_regexp("::")            # => "::"
+    def const_regexp(camel_cased_word) #:nodoc:
+      parts = camel_cased_word.split("::".freeze)
+
+      return Regexp.escape(camel_cased_word) if parts.blank?
+
+      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.uncountable?(result)
+        result
+      else
+        rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+        result
+      end
+    end
+  end
+end