Module | Extlib::Inflection |
In: |
lib/extlib/inflection.rb
|
This module provides english singular <-> plural noun inflections.
plural_of | [R] | |
singular_of | [R] |
By default, camelize converts strings to UpperCamelCase.
camelize will also convert ’/’ to ’::’ which is useful for converting paths to namespaces
@example
"active_record".camelize #=> "ActiveRecord" "active_record/errors".camelize #=> "ActiveRecord::Errors"
# File lib/extlib/inflection.rb, line 27 27: def camelize(lower_case_and_underscored_word, *args) 28: lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase } 29: end
Take an underscored name and make it into a camelized name
@example
"egg_and_hams".classify #=> "EggAndHam" "post".classify #=> "Post"
# File lib/extlib/inflection.rb, line 15 15: def classify(name) 16: camelize(singularize(name.to_s.sub(/.*\./, ''))) 17: end
# File lib/extlib/inflection.rb, line 130 130: def clear(type = :all) 131: if type == :singular || type == :all 132: @singular_of = {} 133: @singular_rules = [] 134: @singularization_rules, @singularization_regex = nil, nil 135: end 136: if type == :plural || type == :all 137: @singular_of = {} 138: @singular_rules = [] 139: @singularization_rules, @singularization_regex = nil, nil 140: end 141: end
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.
@example
"Module".constantize #=> Module "Class".constantize #=> Class
# File lib/extlib/inflection.rb, line 90 90: def constantize(camel_cased_word) 91: unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word 92: raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!" 93: end 94: 95: Object.module_eval("::#{$1}", __FILE__, __LINE__) 96: end
Removes the module part from the expression in the string
@example
"ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections" "Inflections".demodulize #=> "Inflections"
# File lib/extlib/inflection.rb, line 59 59: def demodulize(class_name_in_module) 60: class_name_in_module.to_s.gsub(/^.*::/, '') 61: end
Creates a foreign key name from a class name.
@example
"Message".foreign_key #=> "message_id" "Admin::Post".foreign_key #=> "post_id"
# File lib/extlib/inflection.rb, line 79 79: def foreign_key(class_name, key = "id") 80: underscore(demodulize(class_name.to_s)) << "_" << key.to_s 81: end
Capitalizes the first word and turns underscores into spaces and strips _id. Like titleize, this is meant for creating pretty output.
@example
"employee_salary" #=> "Employee salary" "author_id" #=> "Author"
# File lib/extlib/inflection.rb, line 50 50: def humanize(lower_case_and_underscored_word) 51: lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize 52: end
Convert an English word from singular to plurel.
"boy".plural #=> boys "tomato".plural #=> tomatoes
word<String>: | word to pluralize |
<String>: | pluralized form of word |
Aliased as pluralize (a Railism)
# File lib/extlib/inflection.rb, line 297 297: def plural(word) 298: # special exceptions 299: return "" if word == "" 300: if result = plural_of[word] 301: return result.dup 302: end 303: result = word.dup 304: regex, hash = pluralization_rules 305: result.sub!(regex) {|m| hash[m]} 306: plural_of[word] = result 307: return result 308: end
Define a plurualization rule.
singular<String>: | ending of the word in singular form |
plural<String>: | ending of the word in plural form |
Once the following rule is defined: English::Inflect.singular_rule ‘fe’, ‘ves‘
You can see the following results: irb> "wife".plural
# File lib/extlib/inflection.rb, line 229 229: def plural_rule(singular, plural) 230: @plural_rules << [singular, plural] 231: end
Define a pluralization exception.
singular<String>: | singular form of the word |
plural<String>: | plural form of the word |
# File lib/extlib/inflection.rb, line 163 163: def plural_word(singular, plural) 164: @plural_of[singular] = plural 165: @plural_of[singular.capitalize] = plural.capitalize 166: end
Read prepared pluralization rules.
# File lib/extlib/inflection.rb, line 245 245: def pluralization_rules 246: if defined?(@pluralization_regex) && @pluralization_regex 247: return [@pluralization_regex, @pluralization_hash] 248: end 249: @pluralization_regex = Regexp.new("(" + @plural_rules.map {|s,p| s}.join("|") + ")$", "i") 250: @pluralization_hash = Hash[*@plural_rules.flatten] 251: [@pluralization_regex, @pluralization_hash] 252: end
Define a general rule.
singular<String>: | ending of the word in singular form |
plural<String>: | ending of the word in plural form |
whole_word<Boolean>: | for capitalization, since words can be capitalized (Man => Men) # |
Once the following rule is defined: English::Inflect.rule ‘y’, ‘ies‘
You can see the following results: irb> "fly".plural
irb> "cry".plural
Define a general rule.
# File lib/extlib/inflection.rb, line 189 189: def rule(singular, plural, whole_word = false) 190: singular_rule(singular, plural) 191: plural_rule(singular, plural) 192: word(singular, plural) if whole_word 193: end
Convert an English word from plurel to singular.
"boys".singular #=> boy "tomatoes".singular #=> tomato
word<String>: | word to singularize |
<String>: | singularized form of word |
Aliased as singularize (a Railism)
# File lib/extlib/inflection.rb, line 269 269: def singular(word) 270: if result = singular_of[word] 271: return result.dup 272: end 273: result = word.dup 274: regex, hash = singularization_rules 275: result.sub!(regex) {|m| hash[m]} 276: singular_of[word] = result 277: return result 278: end
Define a singularization rule.
singular<String>: | ending of the word in singular form |
plural<String>: | ending of the word in plural form |
Once the following rule is defined: English::Inflect.singular_rule ‘o’, ‘oes‘
You can see the following results: irb> "heroes".singular
# File lib/extlib/inflection.rb, line 210 210: def singular_rule(singular, plural) 211: @singular_rules << [singular, plural] 212: end
Define a singularization exception.
singular<String>: | singular form of the word |
plural<String>: | plural form of the word |
# File lib/extlib/inflection.rb, line 151 151: def singular_word(singular, plural) 152: @singular_of[plural] = singular 153: @singular_of[plural.capitalize] = singular.capitalize 154: end
Read prepared singularization rules.
# File lib/extlib/inflection.rb, line 234 234: def singularization_rules 235: if defined?(@singularization_regex) && @singularization_regex 236: return [@singularization_regex, @singularization_hash] 237: end 238: # No sorting needed: Regexen match on longest string 239: @singularization_regex = Regexp.new("(" + @singular_rules.map {|s,p| p}.join("|") + ")$", "i") 240: @singularization_hash = Hash[*@singular_rules.flatten].invert 241: [@singularization_regex, @singularization_hash] 242: end
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.
@example
"RawScaledScorer".tableize #=> "raw_scaled_scorers" "egg_and_ham".tableize #=> "egg_and_hams" "fancyCategory".tableize #=> "fancy_categories"
# File lib/extlib/inflection.rb, line 70 70: def tableize(class_name) 71: pluralize(class_name.to_const_path.gsub(/\//, '_')) 72: end
The reverse of camelize. Makes an underscored form from the expression in the string.
Changes ’::’ to ’/’ to convert namespaces to paths.
@example
"ActiveRecord".underscore #=> "active_record" "ActiveRecord::Errors".underscore #=> active_record/errors
# File lib/extlib/inflection.rb, line 40 40: def underscore(camel_cased_word) 41: camel_cased_word.to_const_path 42: end
Defines a general inflection exception case.
singular<String>: | singular form of the word |
plural<String>: | plural form of the word |
Here we define erratum/errata exception case:
English::Inflect.word "erratum", "errata"
In case singular and plural forms are the same omit second argument on call:
English::Inflect.word ‘information‘
# File lib/extlib/inflection.rb, line 124 124: def word(singular, plural=nil) 125: plural = singular unless plural 126: singular_word(singular, plural) 127: plural_word(singular, plural) 128: end