class String

RemoveAccents version 1.0.3 © 2008-2009 Solutions Informatiques Techniconseils inc.

This module adds 2 methods to the string class. Up-to-date version and documentation available at:

www.techniconseils.ca/en/scripts-remove-accents-ruby.php

This script is available under the following license : Creative Commons Attribution-Share Alike 2.5.

See full license and details at : creativecommons.org/licenses/by-sa/2.5/ca/

Version history:

* 1.0.3 : July 23 2009
            Corrected some incorrect character codes. Source is now wikipedia at:
              http://en.wikipedia.org/wiki/ISO/IEC_8859-1#Related_character_maps
            Thanks to Raimon Fernandez for pointing out the incorrect codes.
* 1.0.2 : October 29 2008
            Slightly optimized version of urlize - Jonathan Grenier (jgrenier@techniconseils.ca)
* 1.0.1 : October 29 2008
            First public revision - Jonathan Grenier (jgrenier@techniconseils.ca)

The inflector extension adds inflection instance 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. It exists for backwards compatibility to legacy Sequel code.

Constants

ACCENTS_MAPPING

The extended characters map used by removeaccents. The accented characters are coded here using their numerical equivalent to sidestep encoding issues. These correspond to ISO-8859-1 encoding.

Public Class Methods

inflections() { |Inflections| ... } click to toggle source

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

# File lib/awestruct/util/inflector.rb, line 96
def self.inflections
  yield Inflections if block_given?
  Inflections
end

Public Instance Methods

anchorize(options = {}) click to toggle source

This follows the generated ID rules

# File lib/awestruct/extensions/extend_string.rb, line 87
def anchorize(options = {})
  options[:downcase] ||= true
  options[:convert_spaces] ||= false
  options[:regexp] ||= /[^-_A-Za-z0-9]/
  
  str = self.strip.removeaccents
  str.downcase! if options[:downcase]
  str.gsub!(/\ /,'_') if options[:convert_spaces]
  str.gsub(options[:regexp], '')
end
camelcase(first_letter_in_uppercase = :upper)
Alias for: camelize
camelize(first_letter_in_uppercase = :upper) click to toggle source

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"
# File lib/awestruct/util/inflector.rb, line 111
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
Also aliased as: camelcase
classify() click to toggle source

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"
# File lib/awestruct/util/inflector.rb, line 125
def classify
  sub(/.*\./, '').singularize.camelize
end
constantize() click to toggle source

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
# File lib/awestruct/util/inflector.rb, line 136
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() click to toggle source

Replaces underscores with dashes in the string.

Example

"puni_puni".dasherize #=> "puni-puni"
# File lib/awestruct/util/inflector.rb, line 145
def dasherize
  gsub(/_/, '-')
end
demodulize() click to toggle source

Removes the module part from the expression in the string

Examples

"ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
"Inflections".demodulize #=> "Inflections"
# File lib/awestruct/util/inflector.rb, line 154
def demodulize
  gsub(/^.*::/, '')
end
foreign_key(use_underscore = true) click to toggle source

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"
# File lib/awestruct/util/inflector.rb, line 165
def foreign_key(use_underscore = true)
  "#{demodulize.underscore}#{'_' if use_underscore}id"
end
humanize() click to toggle source

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"
# File lib/awestruct/util/inflector.rb, line 175
def humanize
  gsub(/_id$/, "").gsub(/_/, " ").capitalize
end
pluralize() 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"
"the blue mailman".pluralize #=> "the blue mailmen"
"CamelOctopus".pluralize #=> "CamelOctopi"
# File lib/awestruct/util/inflector.rb, line 188
def pluralize
  result = dup
  Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end
removeaccents() click to toggle source

Remove the accents from the string. Uses String::ACCENTS_MAPPING as the source map.

# File lib/awestruct/extensions/extend_string.rb, line 54
def removeaccents    
  str = String.new(self)
  String::ACCENTS_MAPPING.each {|letter,accents|
    packed = accents.pack('U*')
    rxp = Regexp.new("[#{packed}]", nil)
    str.gsub!(rxp, letter)
  }
  
  str
end
singularize() 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".singluarize #=> "word"
"the blue mailmen".singularize #=> "the blue mailman"
"CamelOctopi".singularize #=> "CamelOctopus"
# File lib/awestruct/util/inflector.rb, line 203
def singularize
  result = dup
  Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end
tableize() click to toggle source

Underscores and pluralizes the string.

Examples

"RawScaledScorer".tableize #=> "raw_scaled_scorers"
"egg_and_ham".tableize #=> "egg_and_hams"
"fancyCategory".tableize #=> "fancy_categories"
# File lib/awestruct/util/inflector.rb, line 215
def tableize
  underscore.pluralize
end
titlecase()
Alias for: titleize
titleize() 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.

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"
# File lib/awestruct/util/inflector.rb, line 227
def titleize
  underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
end
Also aliased as: titlecase
underscore() click to toggle source

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
# File lib/awestruct/util/inflector.rb, line 238
def underscore
  gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
end
urlize(options = {}) click to toggle source

Convert a string to a format suitable for a URL without ever using escaped characters. It calls strip, removeaccents, downcase (optional) then removes the spaces (optional) and finally removes any characters matching the default regexp (/[^-_A-Za-z0-9]/).

Options

  • :downcase => call downcase on the string (defaults to true)

  • :convert_spaces => Convert space to underscore (defaults to false)

  • :regexp => The regexp matching characters that will be converting to an empty string (defaults to /[^-_A-Za-z0-9]/)

# File lib/awestruct/extensions/extend_string.rb, line 75
def urlize(options = {})
  options[:downcase] ||= true
  options[:convert_spaces] ||= false
  options[:regexp] ||= /[^-_A-Za-z0-9]/
  
  str = self.strip.removeaccents
  str.downcase! if options[:downcase]
  str.gsub!(/\ /,'-') if options[:convert_spaces]
  str.gsub(options[:regexp], '')
end