Module: ActiveSupport::Inflector

Extended by:
Inflector
Included in:
Inflector
Defined in:
lib/jinx/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
185
186
 
# File 'lib/jinx/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
    # FL - fixed bug: String doesn't have a first method
    #lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
    lower_case_and_underscored_word[0, 1].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"



310
311
312
313
 
# File 'lib/jinx/active_support/inflector.rb', line 310

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

#constantize(camel_cased_word) ⇒ Object

:nodoc:



347
348
349
350
351
352
353
354
355
356
 
# File 'lib/jinx/active_support/inflector.rb', line 347

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"



220
221
222
 
# File 'lib/jinx/active_support/inflector.rb', line 220

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"



242
243
244
 
# File 'lib/jinx/active_support/inflector.rb', line 242

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"



323
324
325
 
# File 'lib/jinx/active_support/inflector.rb', line 323

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"



230
231
232
233
234
235
 
# File 'lib/jinx/active_support/inflector.rb', line 230

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/jinx/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"



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

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>



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

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/jinx/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/jinx/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"



296
297
298
 
# File 'lib/jinx/active_support/inflector.rb', line 296

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"



197
198
199
 
# File 'lib/jinx/active_support/inflector.rb', line 197

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

#transliterate(string) ⇒ Object

Replaces accented characters with their ascii equivalents.



275
276
277
 
# File 'lib/jinx/active_support/inflector.rb', line 275

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



208
209
210
211
212
213
214
 
# File 'lib/jinx/active_support/inflector.rb', line 208

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