Module: ActiveSupport::Inflector

Extended by:
Inflector
Included in:
Inflector
Defined in:
lib/active_support/inflector.rb

Overview

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, you’ll need to correct it yourself (explained below).

Defined Under Namespace

Classes: Inflections

Instance Method Summary collapse

Instance Method Details

#camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true) ⇒ Object

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"



178
179
180
181
182
183
184
 
# File 'lib/active_support/inflector.rb', line 178

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(/\/(.?)/) { "::#{$1.upcase }" }.gsub(/(?:^|_)(.)/) { $1.upcase  }
  else
    lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
  end
end

#classify(table_name) ⇒ Object

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

Examples:

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

Singular names are not handled correctly:

"business".classify     #=>"Busines"



308
309
310
311
 
# File 'lib/active_support/inflector.rb', line 308

def classify(table_name)
  # strip out any leading schema name
  camelize(singularize(table_name.to_s.sub(/.*\./, '')))
end

#constantize(camel_cased_word) ⇒ Object

:nodoc:



345
346
347
348
349
350
351
352
353
354
 
# File 'lib/active_support/inflector.rb', line 345

def constantize(camel_cased_word)
  names = camel_cased_word.split('::')
  names.shift if names.empty? || names.first.empty?

  constant = Object
  names.each do |name|
    constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
  end
  constant
end

#dasherize(underscored_word) ⇒ Object

Replaces underscores with dashes in the string.

Example:

"puni_puni" #=>"puni-puni"



218
219
220
 
# File 'lib/active_support/inflector.rb', line 218

def dasherize(underscored_word)
  underscored_word.gsub(/_/, '-')
end

#demodulize(class_name_in_module) ⇒ Object

Removes the module part from the expression in the string.

Examples:

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



240
241
242
 
# File 'lib/active_support/inflector.rb', line 240

def demodulize(class_name_in_module)
  class_name_in_module.to_s.gsub(/^.*::/, '')
end

#foreign_key(class_name, separate_class_name_and_id_with_underscore = true) ⇒ Object

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"



321
322
323
 
# File 'lib/active_support/inflector.rb', line 321

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) ⇒ Object

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.

Examples:

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



228
229
230
231
232
233
 
# File 'lib/active_support/inflector.rb', line 228

def humanize(lower_case_and_underscored_word)
  result = lower_case_and_underscored_word.to_s.dup

  inflections.humans.each {  |(rule, replacement)| break if result.gsub!(rule, replacement)  }
  result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
end

#inflections ⇒ Object

Yields a singleton instance of Inflector::Inflections so you can specify additional inflector rules.

Example:

ActiveSupport::Inflector.inflections do |inflect|
  inflect.uncountable "rails"
end



122
123
124
125
126
127
128
 
# File 'lib/active_support/inflector.rb', line 122

def inflections
  if block_given?
    yield Inflections.instance
  else
    Inflections.instance
  end
end

#ordinalize(number) ⇒ Object

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"



376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/active_support/inflector.rb', line 376

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

#parameterize(string, sep = '-') ⇒ Object

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

Examples

class Person
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

@person = Person.find(1)
#=>#<Person id: 1, name: "Donald E. Knuth">

<%= link_to(@person.name, person_path %>
#=><a href="/person/1-donald-e-knuth">Donald E. Knuth</a>



259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'lib/active_support/inflector.rb', line 259

def parameterize(string, sep = '-')
  re_sep = Regexp.escape(sep)
  # replace accented chars with ther ascii equivalents
  parameterized_string = transliterate(string)
  # Turn unwanted chars into the seperator
  parameterized_string.gsub!(/[^a-z0-9\-_\+]+/i, sep)
  # No more than one of the separator in a row.
  parameterized_string.squeeze!(sep)
  # Remove leading/trailing separator.
  parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/i, '')
  parameterized_string.downcase
end

#pluralize(word) ⇒ Object

Returns the plural form of the word in the string.

Examples:

"post".pluralize             #=>"posts"
"octopus".pluralize          #=>"octopi"
"sheep".pluralize            #=>"sheep"
"words".pluralize            #=>"words"
"CamelOctopus".pluralize     #=>"CamelOctopi"



138
139
140
141
142
143
144
145
146
147
 
# File 'lib/active_support/inflector.rb', line 138

def pluralize(word)
  result = word.to_s.dup

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

#singularize(word) ⇒ Object

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".singularize             #=>"word"
"CamelOctopi".singularize      #=>"CamelOctopus"



157
158
159
160
161
162
163
164
165
166
 
# File 'lib/active_support/inflector.rb', line 157

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) ⇒ Object

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"



294
295
296
 
# File 'lib/active_support/inflector.rb', line 294

def tableize(class_name)
  pluralize(underscore(class_name))
end

#titleize(word) ⇒ Object

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"



195
196
197
 
# File 'lib/active_support/inflector.rb', line 195

def titleize(word)
  humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize  }
end

#transliterate(string) ⇒ Object

Replaces accented characters with their ascii equivalents.



273
274
275
 
# File 'lib/active_support/inflector.rb', line 273

def transliterate(string)
  Iconv.iconv('ascii//ignore//translit', 'utf-8', string).to_s
end

#underscore(camel_cased_word) ⇒ Object

The reverse of camelize. Makes an underscored, lowercase 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



206
207
208
209
210
211
212
 
# File 'lib/active_support/inflector.rb', line 206

def underscore(camel_cased_word)
  camel_cased_word.to_s.gsub(/::/, '/').
    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').
    tr("-", "_").
    downcase
end