Ruby on Rails - core extensions string inflection in ruby on rails- ruby on rails tutorial - rails guides - rails tutorial - ruby rails

Returns of plural form of the string. Optionally takes a count parameter and returns singular form if count == 1. Also accepts a locale parameter for language-specific pluralization.

'post'.pluralize             # => "posts"
'octopus'.pluralize          # => "octopi"
'sheep'.pluralize            # => "sheep"
'words'.pluralize            # => "words"
'the blue mailman'.pluralize # => "the blue mailmen"
'CamelOctopus'.pluralize     # => "CamelOctopi"
'apple'.pluralize(1)         # => "apple"
'apple'.pluralize(2)         # => "apples"
'ley'.pluralize(:es)         # => "leyes"
'ley'.pluralize(1, :es)      # => "ley"

Returns the singular form of the string. Accepts an optional locale parameter.

'posts'.singularize            # => "post"
'octopi'.singularize           # => "octopus"
'sheep'.singularize            # => "sheep"
'word'.singularize             # => "word"
'the blue mailmen'.singularize # => "the blue mailman"
'CamelOctopi'.singularize      # => "CamelOctopus"
'leyes'.singularize(:es)       # => "ley"

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.

'Module'.constantize  # => Module
'Class'.constantize   # => Class
'blargle'.constantize # => NameError: wrong constant name blargle

Performs a constantize but returns nil instead of raising NameError.

'Module'.safe_constantize  # => Module
'Class'.safe_constantize   # => Class
'blargle'.safe_constantize # => nil

Converts strings to UpperCamelCase by default, if :lower is given as param converts to lowerCamelCase instead.

Note: will also convert / to :: which is useful for converting paths to namespaces.

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

Capitalizes all the words and replaces some characters in the string to create a nicer looking title.

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

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

Note: underscore will also change :: to / to convert namespaces to paths.

'ActiveModel'.underscore         # => "active_model"
'ActiveModel::Errors'.underscore # => "active_model/errors"

Replaces underscores with dashes in the string.

'puni_puni'.dasherize # => "puni-puni"

Removes the module part from the constant expression in the string.

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

Removes the rightmost segment from the constant expression in the string.

'Net::HTTP'.deconstantize   # => "Net"
'::Net::HTTP'.deconstantize # => "::Net"
'String'.deconstantize      # => ""
'::String'.deconstantize    # => ""
''.deconstantize            # => ""

Replaces special characters in a string so that it may be used as part of a 'pretty' URL.

"Donald E. Knuth".parameterize # => "donald-e-knuth"

Preserve the case of the characters in a string with the :preserve_case argument.

"Donald E. Knuth".parameterize(preserve_case: true) # => "Donald-E-Knuth"

A very common use-case for parameterize is to override the to_param method of an ActiveRecord model to support more descriptive url slugs.

class Person < ActiveRecord::Base
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

Person.find(1).to_param # => "1-donald-e-knuth"

Creates the name of a table like Rails does for models to table names. Pluralizes the last word in the string.

'RawScaledScorer'.tableize # => "raw_scaled_scorers"
'ham_and_egg'.tableize     # => "ham_and_eggs"
'fancyCategory'.tableize   # => "fancy_categories"

Returns a class name string from a plural table name like Rails does for table names to models.

'ham_and_eggs'.classify # => "HamAndEgg"
'posts'.classify        # => "Post"

Capitalizes the first word, turns underscores into spaces, and strips a trailing _id if present.

'employee_salary'.humanize              # => "Employee salary"
'author_id'.humanize                    # => "Author"
'author_id'.humanize(capitalize: false) # => "author"
'_id'.humanize                          # => "Id"

Converts just the first character to uppercase.

'what a Lovely Day'.upcase_first # => "What a Lovely Day"
'w'.upcase_first                 # => "W"
''.upcase_first                  # => ""

Creates a foreign key name from a class name. Pass false param to disable adding _ between name and id.

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