Module: Gorillib::Inflector

Extended by:
Inflector
Included in:
Inflector
Defined in:
lib/gorillib/string/inflector.rb,
lib/gorillib/string/simple_inflector.rb

Overview

String inflections define new methods on the String class to transform names for different purposes.

"ScaleScore".underscore # => "scale_score"

This doesn't define the full set of inflections -- only

  • camelize
  • snakeize
  • underscore
  • demodulize

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.pluralizations ⇒ Object 



17
18
19
 
# File 'lib/gorillib/string/simple_inflector.rb', line 17

def self.pluralizations
  @pluralizations ||= {}
end

Instance Method Details

#camelize(str, first_letter = :upper) ⇒ Object

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.

@example:

"active_record".camelize                # => "ActiveRecord"
"active_record".camelize(:lower)        # => "activeRecord"
"active_record/errors".camelize         # => "ActiveRecord::Errors"
"active_record/errors".camelize(:lower) # => "activeRecord::Errors"

As a rule of thumb you can think of camelize as the inverse of underscore, though there are cases where that does not hold:

"SSLError".underscore.camelize # => "SslError"


33
34
35
36
 
# File 'lib/gorillib/string/inflector.rb', line 33

def camelize(str, first_letter = :upper)
  camelized = str.gsub(/\/(.?)/){ "::#{ $1.upcase }" }.gsub(/(?:^|_)(.)/){ $1.upcase }
  (first_letter == :lower) ? (str[0..0].downcase + camelized[1..-1]) : camelized
end

#classify(table_name) ⇒ Object

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

Singular names are not handled correctly:

"business".classify     # => "Busines"


86
87
88
89
 
# File 'lib/gorillib/string/simple_inflector.rb', line 86

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

#constantize(str) ⇒ 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.

This is the extlib version of String#constantize, which has different behavior wrt using lexical context: see active_support/inflector/methods.rb

Examples:

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


115
116
117
118
119
120
121
 
# File 'lib/gorillib/string/inflector.rb', line 115

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

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

#dasherize(underscored_word) ⇒ Object

Replaces underscores with dashes in the string.

Example:

"puni_puni" # => "puni-puni"


76
77
78
 
# File 'lib/gorillib/string/inflector.rb', line 76

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

#deconstantize(path) ⇒ Object

Removes the rightmost segment from the constant expression in the string:

"Net::HTTP".deconstantize   # => "Net"
"::Net::HTTP".deconstantize # => "::Net"
"String".deconstantize      # => ""
"::String".deconstantize    # => ""
"".deconstantize            # => ""

See also demodulize.



100
101
102
 
# File 'lib/gorillib/string/inflector.rb', line 100

def deconstantize(path)
  path.to_s[0...(path.rindex('::') || 0)] # implementation based on the one in facets' Module#spacename
end

#demodulize(str) ⇒ Object

Removes the module part from the expression in the string:

See also deconstantize.

Examples:

"Gorillib::Inflections".demodulize #=> "Inflections"
"Inflections".demodulize                   #=> "Inflections"


87
88
89
 
# File 'lib/gorillib/string/inflector.rb', line 87

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

#humanize(lower_case_and_underscored_word) ⇒ Object

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

Examples:

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


44
45
46
47
48
 
# File 'lib/gorillib/string/simple_inflector.rb', line 44

def humanize(lower_case_and_underscored_word)
  result = lower_case_and_underscored_word.to_s.dup
  result.gsub!(/_id$/, "")
  result.gsub(/(_)?([a-z\d]*)/i){ "#{ $1 && ' ' }#{ $2.downcase}" }.gsub(/^\w/){ $&.upcase }
end

#ordinalize(number) ⇒ Object

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"
ordinalize(-11)   # => "-11th"
ordinalize(-1021) # => "-1021st"


170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/gorillib/string/inflector.rb', line 170

def ordinalize(number)
  if (11..13).include?(number.to_i.abs % 100)
    "#{number}th"
  else
    case number.to_i.abs % 10
    when 1; "#{number}st"
    when 2; "#{number}nd"
    when 3; "#{number}rd"
    else    "#{number}th"
    end
  end
end

#pluralize(str) ⇒ Object 



21
22
23
 
# File 'lib/gorillib/string/simple_inflector.rb', line 21

def pluralize(str)
  Gorillib::Inflector.pluralizations.fetch(str){ "#{str}s" }
end

#safe_constantize(camel_cased_word) ⇒ Module, Class

Tries to find a declared constant with the name specified in the string, or return nil.

The name is assumed to be the one of a top-level constant, no matter whether it starts with "::" or not. No lexical context is taken into account:

Examples:

"Module".safe_constantize  # => Module
"Class".safe_constantize   # => Class

finds the top-level constant ::C, not ::M::C

C = 'outside'
module M
  C = 'inside'
  C                    # => 'inside'
  "C".safe_constantize # => 'outside', same as ::C
end

nil is returned when the name is not in CamelCase or the constant (or part of it) is unknown.

"blargle".safe_constantize  # => nil
"UnknownModule".safe_constantize  # => nil
"UnknownModule::Foo::Bar".safe_constantize  # => nil

Returns:

  • (Module, Class) —

    the specified constant, or nil when the name is not in CamelCase or is not initialized.

See Also:



149
150
151
152
153
154
155
156
157
158
 
# File 'lib/gorillib/string/inflector.rb', line 149

def safe_constantize(camel_cased_word)
  begin
    constantize(camel_cased_word)
  rescue NameError => e
    raise unless e.message =~ /uninitialized constant #{const_regexp(camel_cased_word)}$/ ||
      e.name.to_s == camel_cased_word.to_s
  rescue ArgumentError => e
    raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
  end
end

#singularize(str) ⇒ Object

The reverse of pluralize, returns the singular form of a word in a string.

Examples:

"posts".singularize            # => "post"
# it's not very smart
"octopi".singularize           # => "octopi"
"bonus".singularize            # => "bonu"
"boxes".singularize            # => "boxe"
"CamelOctopi".singularize      # => "CamelOctopi"


34
35
36
 
# File 'lib/gorillib/string/simple_inflector.rb', line 34

def singularize(str)
  Gorillib::Inflector.pluralizations.invert.fetch(str){ str.gsub(/s$/, '') }
end

#snakeize(str) ⇒ Object

Converts strings to snakeCase, also known as lowerCamelCase.

snakeize will also convert '/' to '::' which is useful for converting paths to namespaces.

@example:

"active_record".snakeize                # => "activeRecord"
"active_record/errors".snakeize         # => "activeRecord::Errors"


46
47
48
 
# File 'lib/gorillib/string/inflector.rb', line 46

def snakeize(str)
  camelize(str, :lower)
end

#tableize(class_name) ⇒ Object

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



72
73
74
 
# File 'lib/gorillib/string/simple_inflector.rb', line 72

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

#titleize(word) ⇒ Object

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"
"TheManWithoutAPast".titleize       # => "The Man Without A Past"
"raiders_of_the_lost_ark".titleize  # => "Raiders Of The Lost Ark"


61
62
63
 
# File 'lib/gorillib/string/simple_inflector.rb', line 61

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

#underscore(str) ⇒ Object

Makes an underscored, lowercase form from the expression in the string.

underscore will also change '::' to '/' to convert namespaces to paths.

Examples:

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

As a rule of thumb you can think of underscore as the inverse of camelize, though there are cases where that does not hold:

"SSLError".underscore.camelize # => "SslError"


62
63
64
65
66
67
68
69
70
 
# File 'lib/gorillib/string/inflector.rb', line 62

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