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.

Namespace
Methods
C
D
F
H
I
O
P
S
T
U
Instance Public methods
camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)

By default, camelize converts strings to UpperCamelCase. If the argument to camelize is set to “:lower” then camelize produces lowerCamelCase.

camelize will also convert ‘/’ to ‘::’ which is useful for converting paths to namespaces

Examples

"active_record".camelize #=> "ActiveRecord"
"active_record".camelize(:lower) #=> "activeRecord"
"active_record/errors".camelize #=> "ActiveRecord::Errors"
"active_record/errors".camelize(:lower) #=> "activeRecord::Errors"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 140
def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
  if first_letter_in_uppercase
    lower_case_and_underscored_word.to_s.gsub(%r\/(.?)/) { "::" + $1.upcase }.gsub(%r(^|_)(.)/) { $2.upcase }
  else
    lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
  end
end
classify(table_name)

Create a class name from a 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.)

Examples

"egg_and_hams".classify #=> "EggAndHam"
"post".classify #=> "Post"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 221
def classify(table_name)
  # strip out any leading schema name
  camelize(singularize(table_name.to_s.sub(%r.*\./, '')))
end
constantize(camel_cased_word)

Constantize tries to find a declared constant with the name specified in the string. It raises a NameError when the name is not in CamelCase or is not initialized.

Examples

"Module".constantize #=> Module
"Class".constantize #=> Class

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 245
def constantize(camel_cased_word)
  unless %r\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
    raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
  end

  Object.module_eval("::#{$1}", __FILE__, __LINE__)
end
dasherize(underscored_word)

Replaces underscores with dashes in the string.

Example

"puni_puni" #=> "puni-puni"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 180
def dasherize(underscored_word)
  underscored_word.gsub(%r_/, '-')
end
demodulize(class_name_in_module)

Removes the module part from the expression in the string

Examples

"ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
"Inflections".demodulize #=> "Inflections"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 199
def demodulize(class_name_in_module)
  class_name_in_module.to_s.gsub(%r^.*::/, '')
end
foreign_key(class_name, separate_class_name_and_id_with_underscore = true)

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’.

Examples

"Message".foreign_key #=> "message_id"
"Message".foreign_key(false) #=> "messageid"
"Admin::Post".foreign_key #=> "post_id"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 234
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
humanize(lower_case_and_underscored_word)

Capitalizes the first word and turns underscores into spaces and strips _id. Like titleize, this is meant for creating pretty output.

Examples

"employee_salary" #=> "Employee salary"
"author_id" #=> "Author"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 190
def humanize(lower_case_and_underscored_word)
  lower_case_and_underscored_word.to_s.gsub(%r_id$/, "").gsub(%r_/, " ").capitalize
end
inflections()

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 82
def inflections
  if block_given?
    yield Inflections.instance
  else
    Inflections.instance
  end
end
ordinalize(number)

Ordinalize turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.

Examples

ordinalize(1)     # => "1st"
ordinalize(2)     # => "2nd"
ordinalize(1002)  # => "1002nd"
ordinalize(1003)  # => "1003rd"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 261
def ordinalize(number)
  if (11..13).include?(number.to_i % 100)
    "#{number}th"
  else
    case number.to_i % 10
      when 1: "#{number}st"
      when 2: "#{number}nd"
      when 3: "#{number}rd"
      else    "#{number}th"
    end
  end
end
pluralize(word)

Returns the plural form of the word in the string.

Examples

"post".pluralize #=> "posts"
"octopus".pluralize #=> "octopi"
"sheep".pluralize #=> "sheep"
"words".pluralize #=> "words"
"the blue mailman".pluralize #=> "the blue mailmen"
"CamelOctopus".pluralize #=> "CamelOctopi"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 99
def pluralize(word)
  result = word.to_s.dup

  if inflections.uncountables.include?(result.downcase)
    result
  else
    inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
    result
  end
end
singularize(word)

The reverse of pluralize, returns the singular form of a word in a string.

Examples

"posts".singularize #=> "post"
"octopi".singularize #=> "octopus"
"sheep".singluarize #=> "sheep"
"word".singluarize #=> "word"
"the blue mailmen".singularize #=> "the blue mailman"
"CamelOctopi".singularize #=> "CamelOctopus"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 119
def singularize(word)
  result = word.to_s.dup

  if inflections.uncountables.include?(result.downcase)
    result
  else
    inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
    result
  end
end
tableize(class_name)

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.

Examples

"RawScaledScorer".tableize #=> "raw_scaled_scorers"
"egg_and_ham".tableize #=> "egg_and_hams"
"fancyCategory".tableize #=> "fancy_categories"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 210
def tableize(class_name)
  pluralize(underscore(class_name))
end
titleize(word)

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 as titlecase

Examples

"man from the boondocks".titleize #=> "Man From The Boondocks"
"x-men: the last stand".titleize #=> "X Men: The Last Stand"

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 157
def titleize(word)
  humanize(underscore(word)).gsub(%r\b([a-z])/) { $1.capitalize }
end
underscore(camel_cased_word)

The reverse of camelize. Makes an underscored form from the expression in the string.

Changes ‘::’ to ‘/’ to convert namespaces to paths.

Examples

"ActiveRecord".underscore #=> "active_record"
"ActiveRecord::Errors".underscore #=> active_record/errors

Source: show 

# File rails/activesupport/lib/active_support/inflector.rb, line 168
def underscore(camel_cased_word)
  camel_cased_word.to_s.gsub(%r::/, '/').
    gsub(%r([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(%r([a-z\d])([A-Z])/,'\1_\2').
    tr("-", "_").
    downcase
end