Module: Inflector

Extended by:
Inflector
Included in:
Inflector
Defined in:
lib/gamebox/lib/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

- (Object) camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)

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"


140
141
142
143
144
145
146
 
# File 'lib/gamebox/lib/inflector.rb', line 140

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(/(^|_)(.)/) { $2.upcase }
  else
    lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
  end
end

- (Object) classify(table_name)

Create a class name from a table name like Rails does for table names to stagels. 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"
"post".classify #=> "Post"


221
222
223
224
 
# File 'lib/gamebox/lib/inflector.rb', line 221

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

- (Object) constantize(camel_cased_word)

Constantize tries to find a declared constant with the name specified in the string. It raises a NameError when the name is not in CamelCase or is not initialized.

Examples

"Module".constantize #=> Module
"Class".constantize #=> Class


245
246
247
248
249
250
251
 
# File 'lib/gamebox/lib/inflector.rb', line 245

def constantize(camel_cased_word)
  unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
    raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
  end

  Object.module_eval("::#{$1}", __FILE__, __LINE__)
end

- (Object) dasherize(underscored_word)

Replaces underscores with dashes in the string.

Example

"puni_puni" #=> "puni-puni"


180
181
182
 
# File 'lib/gamebox/lib/inflector.rb', line 180

def dasherize(underscored_word)
  underscored_word.gsub(/_/, '-')
end

- (Object) demodulize(class_name_in_module)

Removes the module part from the expression in the string

Examples

"ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
"Inflections".demodulize #=> "Inflections"


199
200
201
 
# File 'lib/gamebox/lib/inflector.rb', line 199

def demodulize(class_name_in_module)
  class_name_in_module.to_s.gsub(/^.*::/, '')
end

- (Object) foreign_key(class_name, separate_class_name_and_id_with_underscore = true)

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"


234
235
236
 
# File 'lib/gamebox/lib/inflector.rb', line 234

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

- (Object) humanize(lower_case_and_underscored_word)

Capitalizes the first word and turns underscores into spaces and strips _id. Like titleize, this is meant for creating pretty output.

Examples

"employee_salary" #=> "Employee salary"
"author_id" #=> "Author"


190
191
192
 
# File 'lib/gamebox/lib/inflector.rb', line 190

def humanize(lower_case_and_underscored_word)
  lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
end

- (Object) inflections 



82
83
84
85
86
87
88
 
# File 'lib/gamebox/lib/inflector.rb', line 82

def inflections
  if block_given?
    yield Inflections.instance
  else
    Inflections.instance
  end
end

- (Object) ordinalize(number)

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


261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/gamebox/lib/inflector.rb', line 261

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

- (Object) pluralize(word)

Returns the plural form of the word in the string.

Examples

"post".pluralize #=> "posts"
"octopus".pluralize #=> "octopi"
"sheep".pluralize #=> "sheep"
"words".pluralize #=> "words"
"the blue mailman".pluralize #=> "the blue mailmen"
"CamelOctopus".pluralize #=> "CamelOctopi"


99
100
101
102
103
104
105
106
107
108
 
# File 'lib/gamebox/lib/inflector.rb', line 99

def pluralize(word)
  result = word.to_s.dup

  if inflections.uncountables.include?(result.downcase)
    result
  else
    inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
    result
  end
end

- (Object) singularize(word)

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".singluarize #=> "word"
"the blue mailmen".singularize #=> "the blue mailman"
"CamelOctopi".singularize #=> "CamelOctopus"


119
120
121
122
123
124
125
126
127
128
 
# File 'lib/gamebox/lib/inflector.rb', line 119

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

- (Object) tableize(class_name)

Create the name of a table like Rails does for stagels 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"


210
211
212
 
# File 'lib/gamebox/lib/inflector.rb', line 210

def tableize(class_name)
  pluralize(underscore(class_name))
end

- (Object) titleize(word)

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"


157
158
159
 
# File 'lib/gamebox/lib/inflector.rb', line 157

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

- (Object) underscore(camel_cased_word)

The reverse of camelize. Makes an underscored 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


168
169
170
171
172
173
174
 
# File 'lib/gamebox/lib/inflector.rb', line 168

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