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.

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"



174
175
176
177
178
179
180
 
# File 'lib/active_support/inflector.rb', line 174

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

#constantize(camel_cased_word) ⇒ Object

:nodoc:



304
305
306
307
308
309
310
311
312
313
 
# File 'lib/active_support/inflector.rb', line 304

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"



214
215
216
 
# File 'lib/active_support/inflector.rb', line 214

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"



236
237
238
 
# File 'lib/active_support/inflector.rb', line 236

def demodulize(class_name_in_module)
  class_name_in_module.to_s.gsub(/^.*::/, '')
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"



224
225
226
227
228
229
 
# File 'lib/active_support/inflector.rb', line 224

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



118
119
120
121
122
123
124
 
# File 'lib/active_support/inflector.rb', line 118

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"



335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/active_support/inflector.rb', line 335

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>



255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/active_support/inflector.rb', line 255

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"



134
135
136
137
138
139
140
141
142
143
 
# File 'lib/active_support/inflector.rb', line 134

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"



153
154
155
156
157
158
159
160
161
162
 
# File 'lib/active_support/inflector.rb', line 153

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

#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"



191
192
193
 
# File 'lib/active_support/inflector.rb', line 191

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

#transliterate(string) ⇒ Object

Replaces accented characters with their ascii equivalents.



270
271
272
 
# File 'lib/active_support/inflector.rb', line 270

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



202
203
204
205
206
207
208
 
# File 'lib/active_support/inflector.rb', line 202

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