Module: ActiveSupport::Inflector
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
-
#camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true) ⇒ Object
By default,
camelize
converts strings to UpperCamelCase. -
#classify(table_name) ⇒ Object
Create a class name from a plural table name like Rails does for table names to models.
-
#constantize(camel_cased_word) ⇒ Object
:nodoc:.
-
#dasherize(underscored_word) ⇒ Object
Replaces underscores with dashes in the string.
-
#demodulize(class_name_in_module) ⇒ Object
Removes the module part from the expression in the string.
-
#foreign_key(class_name, separate_class_name_and_id_with_underscore = true) ⇒ Object
Creates a foreign key name from a class name.
-
#humanize(lower_case_and_underscored_word) ⇒ Object
Capitalizes the first word and turns underscores into spaces and strips a trailing “_id”, if any.
-
#inflections ⇒ Object
Yields a singleton instance of Inflector::Inflections so you can specify additional inflector rules.
-
#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.
-
#parameterize(string, sep = '-') ⇒ Object
Replaces special characters in a string so that it may be used as part of a ‘pretty’ URL.
-
#pluralize(word) ⇒ Object
Returns the plural form of the word in the string.
-
#singularize(word) ⇒ Object
The reverse of
pluralize
, returns the singular form of a word in a string. -
#tableize(class_name) ⇒ Object
Create the name of a table like Rails does for models to table names.
-
#titleize(word) ⇒ Object
Capitalizes all the words and replaces some characters in the string to create a nicer looking title.
-
#transliterate(string) ⇒ Object
Replaces accented characters with their ascii equivalents.
-
#underscore(camel_cased_word) ⇒ Object
The reverse of
camelize
.
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"
309 310 311 312 |
# File 'lib/active_support/inflector.rb', line 309 def classify(table_name) # strip out any leading schema name camelize(singularize(table_name.to_s.sub(/.*\./, ''))) end |
#constantize(camel_cased_word) ⇒ Object
:nodoc:
346 347 348 349 350 351 352 353 354 355 |
# File 'lib/active_support/inflector.rb', line 346 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"
322 323 324 |
# File 'lib/active_support/inflector.rb', line 322 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"
377 378 379 380 381 382 383 384 385 386 387 388 |
# File 'lib/active_support/inflector.rb', line 377 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"
295 296 297 |
# File 'lib/active_support/inflector.rb', line 295 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.
274 275 276 |
# File 'lib/active_support/inflector.rb', line 274 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 |