The Inflecto 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).
Convert input to UpperCamelCase
Will also convert '/' to '::' which is useful for converting paths to namespaces.
@param [String] input
@example
Inflecto.camelize("data_mapper") # => "DataMapper" Inflecto.camelize("data_mapper/errors") # => "DataMApper::Errors"
@return [String]
@api public
# File lib/inflecto.rb, line 25 def self.camelize(input) input.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } end
Classify input
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:
Inflecto.classify("egg_and_hams") # => "EggAndHam" Inflecto.classify("posts") # => "Post" # Singular names are not handled correctly: Inflecto.classify("business") # => "Busines"
@return [String]
@api private
# File lib/inflecto.rb, line 299 def self.classify(table_name) # strip out any leading schema name camelize(singularize(table_name.to_s.sub(/.*\./, ''))) end
Find a constant with the name specified in the argument string
The name is assumed to be the one of a top-level constant, constant scope of caller is igored
@param [String] input
@example
Inflecto.constantize("Module") # => Module Inflecto.constantize("DataMapper::Error") # => Test::Unit
@return [Class, Module]
@api private
# File lib/inflecto.rb, line 116 def self.constantize(input) names = input.split('::') names.shift if names.empty? || names.first.empty? constant = Object names.each do |name| # Ruby 1.9 introduces an inherit argument for Module#const_get and # #const_defined? and changes their default behavior. if Module.method(:const_get).arity == 1 constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name) else constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name) end end constant end
Convert input underscores to dashes
@param [String] input
@example
Inflecto.dasherize("foo_bar") # => "foo-bar"
@return [String]
@api public
# File lib/inflecto.rb, line 64 def self.dasherize(input) input.gsub(/_/, '-') end
Return unscoped constant name
@param [String] input
@example
Inflecto.demodulize("DataMapper::Error") # => "Error" Inflecto.demodulize("DataMapper") # => "DataMapper"
@return [String]
@api public
# File lib/inflecto.rb, line 81 def self.demodulize(input) input.to_s.gsub(/^.*::/, '') end
Creates a foreign key name
@param [String] input
@example
Inflecto.foreign_key("Message) => "message_id"
@return [String]
@api private
# File lib/inflecto.rb, line 97 def self.foreign_key(input) "#{underscore(demodulize(input))}_id" end
Humanize string
@param [String] input
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.
@example
Inflecto.humanize("employee_salary") # => "Employee salary" Inflecto.humanize("author_id") # => "Author"
@return [String]
@api private
# File lib/inflecto.rb, line 251 def self.humanize(input) result = input.to_s.dup inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } result.gsub(/_id$/, "").gsub(/_/, " ").capitalize end
Yields a singleton instance of Inflecto::Inflections
@example
Inflecto.inflections do |inflect| inflect.uncountable "rails" end
@return [Inflecto::Inflections]
@api public
# File lib/inflecto.rb, line 173 def self.inflections if block_given? yield Inflections.instance else Inflections.instance end end
Convert a number into an ordinal string
@param [Fixnum] number
@example
ordinalize(1) # => "1st" ordinalize(2) # => "2nd" ordinalize(1002) # => "1002nd" ordinalize(1003) # => "1003rd"
@return [String]
@api private
# File lib/inflecto.rb, line 148 def self.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
Convert input word string to plural
@param [String] word
@example
Inflecto.pluralize("post") # => "posts" Inflecto.pluralize("octopus") # => "octopi" Inflecto.pluralize("sheep") # => "sheep" Inflecto.pluralize("words") # => "words" Inflecto.pluralize("CamelOctopus") # => "CamelOctopi"
@return [String]
@api public
# File lib/inflecto.rb, line 197 def self.pluralize(word) result = word.to_s.dup if result.empty? || inflections.uncountables.include?(result.downcase) result else inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } result end end
Convert word to singular
@param [String] word
@example
Inflecto.singularize("posts") # => "post" Inflecto.singularize("octopi") # => "octopus" Inflecto.singularize("sheep") # => "sheep" Inflecto.singularize("word") # => "word" Inflecto.singularize("CamelOctopi") # => "CamelOctopus"
@return [String]
@api public
# File lib/inflecto.rb, line 224 def self.singularize(word) result = word.to_s.dup if inflections.uncountables.any? { |inflection| result =~ /\b(#{inflection})\Z/ } result else inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } result end end
Tabelize input string
@param [String] input
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.
@example
Inflecto.tabelize("RawScaledScorer") # => "raw_scaled_scorers" Inflecto.tabelize("egg_and_ham") # => "egg_and_hams" Inflecto.tabelize("fancyCategory") # => "fancy_categories"
@return [String]
@api private
# File lib/inflecto.rb, line 276 def self.tableize(input) pluralize(underscore(input).gsub('/','_')) end
Convert input to underscored, lowercase string
Changes '::' to '/' to convert namespaces to paths.
@param [String] input
@example
Inflecto.underscore("DataMapper") # => "data_mapper" Inflecto.underscore("DataMapper::Errors") # => "data_mapper/errors"
@return [String]
@api public
# File lib/inflecto.rb, line 43 def self.underscore(input) word = input.to_s.dup word.gsub!(/::/, '/') word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') word.gsub!(/([a-z\d])([A-Z])/,'\1_\2') word.tr!("-", "_") word.downcase! word end