Module Extlib::Inflection
In: lib/extlib/inflection.rb
::String ByteArray Hash SimpleSet StandardError InvalidResourceError Logger Pool lib/extlib/logger.rb lib/extlib/simple_set.rb lib/extlib/byte_array.rb ClassMethods Hook Assertions lib/extlib/pooling.rb Pooling Inflection Extlib dot/m_31_0.png

English Nouns Number Inflection.

This module provides english singular <-> plural noun inflections.

Methods

External Aliases

singular -> singularize
  Alias for singular (a Railism).
plural -> pluralize
  Alias for plural (a Railism).

Attributes

plural_of  [R] 
singular_of  [R] 

Public Class methods

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"

[Source]

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

[Source]

    # File lib/extlib/inflection.rb, line 15
15:       def classify(name)
16:         camelize(singularize(name.to_s.sub(/.*\./, '')))
17:       end

[Source]

     # 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

[Source]

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

[Source]

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

[Source]

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

[Source]

    # 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

Parameters

word<String>:word to pluralize

Returns

<String>:pluralized form of word

Notes

Aliased as pluralize (a Railism)

[Source]

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

Parameters

singular<String>:ending of the word in singular form
plural<String>:ending of the word in plural form

Examples

Once the following rule is defined: English::Inflect.singular_rule ‘fe’, ‘ves‘

You can see the following results: irb> "wife".plural

> wives

[Source]

     # File lib/extlib/inflection.rb, line 229
229:       def plural_rule(singular, plural)
230:         @plural_rules << [singular, plural]
231:       end

Define a pluralization exception.

Parameters

singular<String>:singular form of the word
plural<String>:plural form of the word

[Source]

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

[Source]

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

Parameters

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

Examples

Once the following rule is defined: English::Inflect.rule ‘y’, ‘ies‘

You can see the following results: irb> "fly".plural

> flies

irb> "cry".plural

> cries

Define a general rule.

[Source]

     # 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

Parameters

word<String>:word to singularize

Returns

<String>:singularized form of word

Notes

Aliased as singularize (a Railism)

[Source]

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

Parameters

singular<String>:ending of the word in singular form
plural<String>:ending of the word in plural form

Examples

Once the following rule is defined: English::Inflect.singular_rule ‘o’, ‘oes‘

You can see the following results: irb> "heroes".singular

> hero

[Source]

     # File lib/extlib/inflection.rb, line 210
210:       def singular_rule(singular, plural)
211:         @singular_rules << [singular, plural]
212:       end

Define a singularization exception.

Parameters

singular<String>:singular form of the word
plural<String>:plural form of the word

[Source]

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

[Source]

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

[Source]

    # 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

[Source]

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

Parameters

singular<String>:singular form of the word
plural<String>:plural form of the word

Examples

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‘

[Source]

     # 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

[Validate]