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
-
#camelize(str, first_letter = :upper) ⇒ Object
By default, +camelize+ converts strings to UpperCamelCase.
-
#classify(table_name) ⇒ Object
Create a class name from a plural table name like Rails does for table names to models.
-
#constantize(str) ⇒ Object
Constantize tries to find a declared constant with the name specified in the string.
-
#dasherize(underscored_word) ⇒ Object
Replaces underscores with dashes in the string.
-
#deconstantize(path) ⇒ Object
Removes the rightmost segment from the constant expression in the string:.
-
#demodulize(str) ⇒ Object
Removes the module part from the expression in the string:.
-
#humanize(lower_case_and_underscored_word) ⇒ Object
Capitalizes the first word and turns underscores into spaces and strips a trailing "_id", if any.
-
#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.
- #pluralize(str) ⇒ Object
-
#safe_constantize(camel_cased_word) ⇒ Module, Class
Tries to find a declared constant with the name specified in the string, or return nil.
-
#singularize(str) ⇒ Object
The reverse of +pluralize+, returns the singular form of a word in a string.
-
#snakeize(str) ⇒ Object
Converts strings to snakeCase, also known as lowerCamelCase.
-
#tableize(class_name) ⇒ Object
Create the name of a table like Rails does for models to table names.
-
#titleize(word) ⇒ Object
Capitalizes all the words and replaces some characters in the string to create a nicer looking title.
-
#underscore(str) ⇒ Object
Makes an underscored, lowercase form from the expression in the string.
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
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+.
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:
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. =~ /uninitialized constant #{const_regexp(camel_cased_word)}$/ || e.name.to_s == camel_cased_word.to_s rescue ArgumentError => e raise unless e. =~ /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 |