camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
click to toggle source
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"
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)
click to toggle source
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"
def classify(table_name)
camelize(singularize(table_name.to_s.sub(/.*\./, '')))
end
constantize(camel_cased_word)
click to toggle source
Tries to find a constant with the name specified in the argument string:
"Module".constantize # => Module
"Test::Unit".constantize # => Test::Unit
The name is assumed to be the one of a top-level constant, no matter
whether it starts with “::” or not. No lexical context is taken into
account:
C = 'outside'
module M
C = 'inside'
C # => 'inside'
"C".constantize # => 'outside', same as ::C
end
NameError is raised when the name is not in CamelCase or the constant is
unknown.
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)
click to toggle source
Replaces underscores with dashes in the string.
Example:
"puni_puni" # => "puni-puni"
def dasherize(underscored_word)
underscored_word.gsub(/_/, '-')
end
demodulize(class_name_in_module)
click to toggle source
Removes the module part from the expression in the string.
Examples:
"ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
"Inflections".demodulize # => "Inflections"
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)
click to toggle source
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"
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)
click to toggle source
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"
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()
click to toggle source
Yields a singleton instance of Inflector::Inflections so you can
specify additional inflector rules.
Example:
ActiveSupport::Inflector.inflections do |inflect|
inflect.uncountable "rails"
end
def inflections
if block_given?
yield Inflections.instance
else
Inflections.instance
end
end
ordinalize(number)
click to toggle source
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"
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 = '-')
click to toggle source
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(@person)) %>
# => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
def parameterize(string, sep = '-')
string = string.toutf8 unless string.is_utf8?
parameterized_string = transliterate(string)
parameterized_string.gsub!(/[^a-z0-9\-_]+/, sep)
unless sep.blank?
re_sep = Regexp.escape(sep)
parameterized_string.gsub!(/#{re_sep}{2,}/, sep)
parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/, '')
end
parameterized_string.downcase
end
pluralize(word)
click to toggle source
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"
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)
click to toggle source
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"
def singularize(word)
result = word.to_s.dup
if inflections.uncountables.any? { |inflection| result =~ /#{inflection}\Z/ }
result
else
inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
result
end
end
tableize(class_name)
click to toggle source
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"
def tableize(class_name)
pluralize(underscore(class_name))
end
titleize(word)
click to toggle source
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"
def titleize(word)
humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
end
transliterate(string)
click to toggle source
Replaces accented characters with their ascii equivalents.
def transliterate(string)
Iconv.iconv('ascii//ignore//translit', 'utf-8', string).to_s
end
underscore(camel_cased_word)
click to toggle source
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
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
![[+]](../images/find.png "show/hide quicksearch")