update AS/inflector docs [ci skip]

3 files changed, 167 insertions, 142 deletions

diff --git a/activesupport/lib/active_support/inflector/inflections.rb b/activesupport/lib/active_support/inflector/inflections.rb
index 091692e5a4..af506d6f2e 100644
--- a/activesupport/lib/active_support/inflector/inflections.rb
+++ b/activesupport/lib/active_support/inflector/inflections.rb
@@ -5,9 +5,10 @@ module ActiveSupport
   module Inflector
     extend self
 
-    # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
-    # inflection rules. If passed an optional locale, rules for other languages can be specified. The default locale is
-    # <tt>:en</tt>. Only rules for English are provided.
+    # A singleton instance of this class is yielded by Inflector.inflections,
+    # which can then be used to specify additional inflection rules. If passed
+    # an optional locale, rules for other languages can be specified. The
+    # default locale is <tt>:en</tt>. Only rules for English are provided.
     #
     #   ActiveSupport::Inflector.inflections(:en) do |inflect|
     #     inflect.plural /^(ox)$/i, '\1\2en'
@@ -15,12 +16,13 @@ module ActiveSupport
     #
     #     inflect.irregular 'octopus', 'octopi'
     #
-    #     inflect.uncountable "equipment"
+    #     inflect.uncountable 'equipment'
     #   end
     #
-    # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
-    # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
-    # already have been loaded.
+    # New rules are added at the top. So in the example above, the irregular
+    # rule for octopus will now be the first of the pluralization and
+    # singularization rules that is runs. This guarantees that your rules run
+    # before any of the rules that may already have been loaded.
     class Inflections
       def self.instance(locale = :en)
         @__instance__ ||= Hash.new { |h, k| h[k] = new }
@@ -34,36 +36,40 @@ module ActiveSupport
       end
 
       # Private, for the test suite.
-      def initialize_dup(orig)
+      def initialize_dup(orig) # :nodoc:
         %w(plurals singulars uncountables humans acronyms acronym_regex).each do |scope|
           instance_variable_set("@#{scope}", orig.send(scope).dup)
         end
       end
 
-      # Specifies a new acronym. An acronym must be specified as it will appear in a camelized string.  An underscore
-      # string that contains the acronym will retain the acronym when passed to `camelize`, `humanize`, or `titleize`.
-      # A camelized string that contains the acronym will maintain the acronym when titleized or humanized, and will
-      # convert the acronym into a non-delimited single lowercase word when passed to +underscore+.
+      # Specifies a new acronym. An acronym must be specified as it will appear
+      # in a camelized string. An underscore string that contains the acronym
+      # will retain the acronym when passed to +camelize+, +humanize+, or
+      # +titleize+. A camelized string that contains the acronym will maintain
+      # the acronym when titleized or humanized, and will convert the acronym
+      # into a non-delimited single lowercase word when passed to +underscore+.
       #
       #   acronym 'HTML'
-      #   titleize 'html' #=> 'HTML'
-      #   camelize 'html' #=> 'HTML'
+      #   titleize 'html'     #=> 'HTML'
+      #   camelize 'html'     #=> 'HTML'
       #   underscore 'MyHTML' #=> 'my_html'
       #
-      # The acronym, however, must occur as a delimited unit and not be part of another word for conversions to recognize it:
+      # The acronym, however, must occur as a delimited unit and not be part of
+      # another word for conversions to recognize it:
       #
       #   acronym 'HTTP'
       #   camelize 'my_http_delimited' #=> 'MyHTTPDelimited'
-      #   camelize 'https' #=> 'Https', not 'HTTPs'
-      #   underscore 'HTTPS' #=> 'http_s', not 'https'
+      #   camelize 'https'             #=> 'Https', not 'HTTPs'
+      #   underscore 'HTTPS'           #=> 'http_s', not 'https'
       #
       #   acronym 'HTTPS'
-      #   camelize 'https' #=> 'HTTPS'
+      #   camelize 'https'   #=> 'HTTPS'
       #   underscore 'HTTPS' #=> 'https'
       #
-      # Note: Acronyms that are passed to `pluralize` will no longer be recognized, since the acronym will not occur as
-      # a delimited unit in the pluralized result. To work around this, you must specify the pluralized form as an
-      # acronym as well:
+      # Note: Acronyms that are passed to +pluralize+ will no longer be
+      # recognized, since the acronym will not occur as a delimited unit in the
+      # pluralized result. To work around this, you must specify the pluralized
+      # form as an acronym as well:
       #
       #    acronym 'API'
       #    camelize(pluralize('api')) #=> 'Apis'
@@ -71,42 +77,49 @@ module ActiveSupport
       #    acronym 'APIs'
       #    camelize(pluralize('api')) #=> 'APIs'
       #
-      # `acronym` may be used to specify any word that contains an acronym or otherwise needs to maintain a non-standard
-      # capitalization. The only restriction is that the word must begin with a capital letter.
+      # +acronym+ may be used to specify any word that contains an acronym or
+      # otherwise needs to maintain a non-standard capitalization. The only
+      # restriction is that the word must begin with a capital letter.
       #
       #   acronym 'RESTful'
-      #   underscore 'RESTful' #=> 'restful'
+      #   underscore 'RESTful'           #=> 'restful'
       #   underscore 'RESTfulController' #=> 'restful_controller'
-      #   titleize 'RESTfulController' #=> 'RESTful Controller'
-      #   camelize 'restful' #=> 'RESTful'
-      #   camelize 'restful_controller' #=> 'RESTfulController'
+      #   titleize 'RESTfulController'   #=> 'RESTful Controller'
+      #   camelize 'restful'             #=> 'RESTful'
+      #   camelize 'restful_controller'  #=> 'RESTfulController'
       #
       #   acronym 'McDonald'
       #   underscore 'McDonald' #=> 'mcdonald'
-      #   camelize 'mcdonald' #=> 'McDonald'
+      #   camelize 'mcdonald'   #=> 'McDonald'
       def acronym(word)
         @acronyms[word.downcase] = word
         @acronym_regex = /#{@acronyms.values.join("|")}/
       end
 
-      # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
-      # The replacement should always be a string that may include references to the matched data from the rule.
+      # Specifies a new pluralization rule and its replacement. The rule can
+      # either be a string or a regular expression. The replacement should
+      # always be a string that may include references to the matched data from
+      # the rule.
       def plural(rule, replacement)
         @uncountables.delete(rule) if rule.is_a?(String)
         @uncountables.delete(replacement)
         @plurals.prepend([rule, replacement])
       end
 
-      # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
-      # The replacement should always be a string that may include references to the matched data from the rule.
+      # Specifies a new singularization rule and its replacement. The rule can
+      # either be a string or a regular expression. The replacement should
+      # always be a string that may include references to the matched data from
+      # the rule.
       def singular(rule, replacement)
         @uncountables.delete(rule) if rule.is_a?(String)
         @uncountables.delete(replacement)
         @singulars.prepend([rule, replacement])
       end
 
-      # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
-      # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+      # Specifies a new irregular that applies to both pluralization and
+      # singularization at the same time. This can only be used for strings, not
+      # regular expressions. You simply pass the irregular in singular and
+      # plural form.
       #
       #   irregular 'octopus', 'octopi'
       #   irregular 'person', 'people'
@@ -129,26 +142,29 @@ module ActiveSupport
 
       # Add uncountable words that shouldn't be attempted inflected.
       #
-      #   uncountable "money"
-      #   uncountable "money", "information"
+      #   uncountable 'money'
+      #   uncountable 'money', 'information'
       #   uncountable %w( money information rice )
       def uncountable(*words)
         (@uncountables << words).flatten!
       end
 
-      # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
-      # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
-      # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
+      # Specifies a humanized form of a string by a regular expression rule or
+      # by a string mapping. When using a regular expression based replacement,
+      # the normal humanize formatting is called after the replacement. When a
+      # string is used, the human form should be specified as desired (example:
+      # 'The name', not 'the_name').
       #
       #   human /_cnt$/i, '\1_count'
-      #   human "legacy_col_person_name", "Name"
+      #   human 'legacy_col_person_name', 'Name'
       def human(rule, replacement)
         @humans.prepend([rule, replacement])
       end
 
-      # Clears the loaded inflections within a given scope (default is <tt>:all</tt>).
-      # Give the scope as a symbol of the inflection type, the options are: <tt>:plurals</tt>,
-      # <tt>:singulars</tt>, <tt>:uncountables</tt>, <tt>:humans</tt>.
+      # Clears the loaded inflections within a given scope (default is
+      # <tt>:all</tt>). Give the scope as a symbol of the inflection type, the
+      # options are: <tt>:plurals</tt>, <tt>:singulars</tt>, <tt>:uncountables</tt>,
+      # <tt>:humans</tt>.
       #
       #   clear :all
       #   clear :plurals
@@ -162,13 +178,13 @@ module ActiveSupport
       end
     end
 
-    # Yields a singleton instance of Inflector::Inflections so you can specify additional
-    # inflector rules. If passed an optional locale, rules for other languages can be specified.
-    # If not specified, defaults to <tt>:en</tt>. Only rules for English are provided.
-    # 
+    # Yields a singleton instance of Inflector::Inflections so you can specify
+    # additional inflector rules. If passed an optional locale, rules for other
+    # languages can be specified. If not specified, defaults to <tt>:en</tt>.
+    # Only rules for English are provided.
     #
     #   ActiveSupport::Inflector.inflections(:en) do |inflect|
-    #     inflect.uncountable "rails"
+    #     inflect.uncountable 'rails'
     #   end
     def inflections(locale = :en)
       if block_given?
diff --git a/activesupport/lib/active_support/inflector/methods.rb b/activesupport/lib/active_support/inflector/methods.rb
index 44214d16fa..3910a2dc42 100644
--- a/activesupport/lib/active_support/inflector/methods.rb
+++ b/activesupport/lib/active_support/inflector/methods.rb
@@ -4,14 +4,16 @@ require 'active_support/inflector/inflections'
 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 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).
+  # 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
 
@@ -21,46 +23,49 @@ module ActiveSupport
     # pluralized using rules defined for that language. By default,
     # this parameter is set to <tt>:en</tt>.
     #
-    #   "post".pluralize             # => "posts"
-    #   "octopus".pluralize          # => "octopi"
-    #   "sheep".pluralize            # => "sheep"
-    #   "words".pluralize            # => "words"
-    #   "CamelOctopus".pluralize     # => "CamelOctopi"
-    #   "ley".pluralize(:es)         # => "leyes"
+    #   'post'.pluralize             # => "posts"
+    #   'octopus'.pluralize          # => "octopi"
+    #   'sheep'.pluralize            # => "sheep"
+    #   'words'.pluralize            # => "words"
+    #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+    #   'ley'.pluralize(: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.
+    # The reverse of +pluralize+, returns the singular form of a word in a
+    # 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>.
     #
-    #   "posts".singularize            # => "post"
-    #   "octopi".singularize           # => "octopus"
-    #   "sheep".singularize            # => "sheep"
-    #   "word".singularize             # => "word"
-    #   "CamelOctopi".singularize      # => "CamelOctopus"
-    #   "leyes".singularize(:es)       # => "ley"
+    #   'posts'.singularize            # => "post"
+    #   'octopi'.singularize           # => "octopus"
+    #   'sheep'.singularize            # => "sheep"
+    #   'word'.singularize             # => "word"
+    #   'CamelOctopi'.singularize      # => "CamelOctopus"
+    #   'leyes'.singularize(:es)       # => "ley"
     def singularize(word, locale = :en)
       apply_inflections(word, inflections(locale).singulars)
     end
 
-    # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
-    # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+    # 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.
+    # +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"
+    #   '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:
+    # 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"
+    #   'SSLError'.underscore.camelize # => "SslError"
     def camelize(term, uppercase_first_letter = true)
       string = term.to_s
       if uppercase_first_letter
@@ -75,13 +80,13 @@ module ActiveSupport
     #
     # Changes '::' to '/' to convert namespaces to paths.
     #
-    #   "ActiveModel".underscore         # => "active_model"
-    #   "ActiveModel::Errors".underscore # => "active_model/errors"
+    #   '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:
+    # 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"
+    #   'SSLError'.underscore.camelize # => "SslError"
     def underscore(camel_cased_word)
       word = camel_cased_word.to_s.dup
       word.gsub!('::', '/')
@@ -94,10 +99,11 @@ module ActiveSupport
     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.
+    # trailing "_id", if any. Like +titleize+, this is meant for creating pretty
+    # output.
     #
-    #   "employee_salary" # => "Employee salary"
-    #   "author_id"       # => "Author"
+    #   '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) }
@@ -108,39 +114,40 @@ module ActiveSupport
       }.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.
+    # 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"
+    #   '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.
+    # 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"
+    #   '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+.)
+    # 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"
+    #   'egg_and_hams'.classify # => "EggAndHam"
+    #   'posts'.classify        # => "Post"
     #
     # Singular names are not handled correctly:
-    #   "business".classify     # => "Busines"
+    #
+    #   'business'.classify     # => "Busines"
     def classify(table_name)
       # strip out any leading schema name
       camelize(singularize(table_name.to_s.sub(/.*\./, '')))
@@ -148,15 +155,15 @@ module ActiveSupport
 
     # Replaces underscores with dashes in the string.
     #
-    #   "puni_puni".dasherize # => "puni-puni"
+    #   'puni_puni'.dasherize # => "puni-puni"
     def dasherize(underscored_word)
       underscored_word.tr('_', '-')
     end
 
-    # Removes the module part from the expression in the string:
+    # Removes the module part from the expression in the string.
     #
-    #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-    #   "Inflections".demodulize                                       # => "Inflections"
+    #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+    #   'Inflections'.demodulize                                       # => "Inflections"
     #
     # See also +deconstantize+.
     def demodulize(path)
@@ -168,13 +175,13 @@ module ActiveSupport
       end
     end
 
-    # Removes the rightmost segment from the constant expression in the string:
+    # Removes the rightmost segment from the constant expression in the string.
     #
-    #   "Net::HTTP".deconstantize   # => "Net"
-    #   "::Net::HTTP".deconstantize # => "::Net"
-    #   "String".deconstantize      # => ""
-    #   "::String".deconstantize    # => ""
-    #   "".deconstantize            # => ""
+    #   'Net::HTTP'.deconstantize   # => "Net"
+    #   '::Net::HTTP'.deconstantize # => "::Net"
+    #   'String'.deconstantize      # => ""
+    #   '::String'.deconstantize    # => ""
+    #   ''.deconstantize            # => ""
     #
     # See also +demodulize+.
     def deconstantize(path)
@@ -185,26 +192,27 @@ module ActiveSupport
     # +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"
+    #   '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:
+    # Tries to find a constant with the name specified in the argument string.
     #
-    #   "Module".constantize     # => Module
-    #   "Test::Unit".constantize # => Test::Unit
+    #   '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:
+    # 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
+    #     'C'.constantize # => 'outside', same as ::C
     #   end
     #
     # NameError is raised when the name is not in CamelCase or the constant is
@@ -235,28 +243,28 @@ module ActiveSupport
       end
     end
 
-    # Tries to find a constant with the name specified in the argument string:
+    # Tries to find a constant with the name specified in the argument string.
     #
-    #   "Module".safe_constantize     # => Module
-    #   "Test::Unit".safe_constantize # => Test::Unit
+    #   '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:
+    # 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
+    #     '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
+    # +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)
@@ -318,8 +326,8 @@ module ActiveSupport
 
     # Applies inflection rules for +singularize+ and +pluralize+.
     #
-    #  apply_inflections("post", inflections.plurals) # => "posts"
-    #  apply_inflections("posts", inflections.singulars) # => "post"
+    #  apply_inflections('post', inflections.plurals)    # => "posts"
+    #  apply_inflections('posts', inflections.singulars) # => "post"
     def apply_inflections(word, rules)
       result = word.to_s.dup
 
diff --git a/activesupport/lib/active_support/inflector/transliterate.rb b/activesupport/lib/active_support/inflector/transliterate.rb
index 459972081c..1cde417fc5 100644
--- a/activesupport/lib/active_support/inflector/transliterate.rb
+++ b/activesupport/lib/active_support/inflector/transliterate.rb
@@ -39,13 +39,13 @@ module ActiveSupport
     #     }
     #   })
     #
-    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that maps
-    # characters to ASCII approximations as shown above, or, for more complex
-    # requirements, a Proc:
+    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that
+    # maps characters to ASCII approximations as shown above, or, for more
+    # complex requirements, a Proc:
     #
     #   I18n.backend.store_translations(:de, i18n: {
     #     transliterate: {
-    #       rule: lambda { |string| MyTransliterator.transliterate(string) }
+    #       rule: ->(string) { MyTransliterator.transliterate(string) }
     #     }
     #   })
     #
@@ -64,7 +64,8 @@ module ActiveSupport
           :replacement => replacement)
     end
 
-    # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
+    # Replaces special characters in a string so that it may be used as part of
+    # a 'pretty' URL.
     #
     #   class Person
     #     def to_param