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:

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 ([email protected])
* 1.0.1 : October 29 2008
            First public revision - Jonathan Grenier ([email protected])

Defined Under Namespace

Modules: Inflections

Constant Summary collapse

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

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

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

#anchorize(options = {}) ⇒ Object

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

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



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

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



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

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) 


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

#dasherize ⇒ Object

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

#demodulize ⇒ Object

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

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



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

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"



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

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"



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

#removeaccents ⇒ Object

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)
    str.gsub!(rxp, letter)
  }
  
  str
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"



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

#tableize ⇒ Object

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

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



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

#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



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

#urlize(options = {}) ⇒ Object

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