Class: String

Inherits:
Object
  • Object
show all
Defined in:
lib/awestruct/util/inflector.rb,
lib/awestruct/extensions/extend_string.rb

Overview

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:

http://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 : http://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)

Defined Under Namespace

Modules: Inflections

Constant Summary

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. 

{
  'E' => [200,201,202,203],
  'e' => [232,233,234,235],
  'A' => [192,193,194,195,196,197],
  'a' => [224,225,226,227,228,229,230],
  'C' => [199],
  'c' => [231],
  'O' => [210,211,212,213,214,216],
  'o' => [242,243,244,245,246,248],
  'I' => [204,205,206,207],
  'i' => [236,237,238,239],
  'U' => [217,218,219,220],
  'u' => [249,250,251,252],
  'N' => [209],
  'n' => [241],
  'Y' => [221],
  'y' => [253,255],
  'AE' => [306],
  'ae' => [346],
  'OE' => [188],
  'oe' => [189]
}

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

+ (Object) inflections {|Inflections| ... }

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

Yields:



96
97
98
99
 
# File 'lib/awestruct/util/inflector.rb', line 96

def self.inflections
  yield Inflections if block_given?
  Inflections
end

Instance Method Details

- (Object) anchorize(options = {})

This follows the generated ID rules 



87
88
89
90
91
92
93
94
95
96
 
# 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

- (Object) camelize(first_letter_in_uppercase = :upper) 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"



111
112
113
114
115
 
# 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

- (Object) classify

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"



125
126
127
 
# File 'lib/awestruct/util/inflector.rb', line 125

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

- (Object) constantize

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) 


136
137
138
139
 
# 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

- (Object) dasherize

Replaces underscores with dashes in the string.

Example 


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



145
146
147
 
# File 'lib/awestruct/util/inflector.rb', line 145

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

- (Object) demodulize

Removes the module part from the expression in the string

Examples 


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



154
155
156
 
# File 'lib/awestruct/util/inflector.rb', line 154

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

- (Object) foreign_key(use_underscore = true)

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"



165
166
167
 
# File 'lib/awestruct/util/inflector.rb', line 165

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

- (Object) humanize

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"



175
176
177
 
# File 'lib/awestruct/util/inflector.rb', line 175

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

- (Object) pluralize

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"



188
189
190
191
192
 
# 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

- (Object) removeaccents

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



54
55
56
57
58
59
60
61
62
63
 
# 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, 'U')
    str.gsub!(rxp, letter)
  }
  
  str
end

- (Object) singularize

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"



203
204
205
206
207
 
# 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

- (Object) tableize

Underscores and pluralizes the string.

Examples 


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



215
216
217
 
# File 'lib/awestruct/util/inflector.rb', line 215

def tableize
  underscore.pluralize
end

- (Object) titleize 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"



227
228
229
 
# File 'lib/awestruct/util/inflector.rb', line 227

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

- (Object) underscore

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



238
239
240
241
 
# 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

- (Object) urlize(options = {})

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]/) 


75
76
77
78
79
80
81
82
83
84
 
# 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