Class: String

Inherits:
Object
  • Object
show all
Defined in:
lib/datafiniti/inflector.rb,
lib/datafiniti/api.rb

Overview

Copyright © 2008-2009 The Rubyists, LLC (effortless systems) <[email protected]> Distributed under the terms of the MIT license. See the LICENSE file that accompanied this software for the full MIT License text

Add inflection methods to String, which allows the easy transformation of words from singular to plural,class names to table names, modularized class names to ones without, and class names to foreign keys.

Defined Under Namespace

Modules: Inflections

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.inflections {|Inflections| ... } ⇒ Object

Yield the Inflections module if a block is given, and return the Inflections module.

Yields:



141
142
143
144
 
# File 'lib/datafiniti/inflector.rb', line 141

def self.inflections
  yield Inflections if block_given?
  Inflections
end

Instance Method Details

#camelize(first_letter_in_uppercase = :upper) ⇒ Object Also known as: camelcase

By default, camelize converts the string 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"



156
157
158
159
160
 
# File 'lib/datafiniti/inflector.rb', line 156

def camelize(first_letter_in_uppercase = :upper)
  s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
  s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
  s
end

#classify ⇒ Object

Singularizes and camelizes the string. Also strips out all characters preceding and including a period (“.”).

Examples

"egg_and_hams".classify #=> "EggAndHam"
"post".classify #=> "Post"
"schema.post".classify #=> "Post"



170
171
172
 
# File 'lib/datafiniti/inflector.rb', line 170

def classify
  sub(/.*\./, '').singularize.camelize
end

#constantize ⇒ Object

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

Raises:

  • (NameError) 


181
182
183
184
 
# File 'lib/datafiniti/inflector.rb', line 181

def constantize
  raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
  Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
end

#dasherize ⇒ Object

Replaces underscores with dashes in the string.

Example

"puni_puni".dasherize #=> "puni-puni"



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

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

#demodulize ⇒ Object

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/datafiniti/inflector.rb', line 199

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

#foreign_key(use_underscore = true) ⇒ Object

Creates a foreign key name from a class name. use_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"



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

def foreign_key(use_underscore = true)
  "#{demodulize.underscore}#{'_' if use_underscore}id"
end

#humanize ⇒ Object

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"



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

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

#pluralize ⇒ Object

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"



233
234
235
236
237
 
# File 'lib/datafiniti/inflector.rb', line 233

def pluralize
  result = dup
  Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end

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



248
249
250
251
252
 
# File 'lib/datafiniti/inflector.rb', line 248

def singularize
  result = dup
  Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end

#status ⇒ Object 



138
139
140
 
# File 'lib/datafiniti/api.rb', line 138

def status
  return 204
end

#tableize ⇒ Object

Underscores and pluralizes the string.

Examples

"RawScaledScorer".tableize #=> "raw_scaled_scorers"
"egg_and_ham".tableize #=> "egg_and_hams"
"fancyCategory".tableize #=> "fancy_categories"



260
261
262
 
# File 'lib/datafiniti/inflector.rb', line 260

def tableize
  underscore.pluralize
end

#titleize ⇒ Object Also known as: titlecase

Capitalizes all the words and replaces some characters in the string to create a nicer looking title. Titleize is meant for creating pretty output.

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"



272
273
274
 
# File 'lib/datafiniti/inflector.rb', line 272

def titleize
  underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
end

#underscore ⇒ Object

The reverse of camelize. Makes an underscored form from the expression in the string. Also changes ‘::’ to ‘/’ to convert namespaces to paths.

Examples

"ActiveRecord".underscore #=> "active_record"
"ActiveRecord::Errors".underscore #=> active_record/errors



283
284
285
286
 
# File 'lib/datafiniti/inflector.rb', line 283

def underscore
  gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
end