Module: String::Inflections

Defined in:
lib/core_ext/string.rb

Overview

This module acts as a singleton returned/yielded by String.inflections, which is used to override or specify additional inflection rules. Examples:

String.inflections do |inflect|
  inflect.plural /^(ox)$/i, '\1\2en'
  inflect.singular /^(ox)en/i, '\1'

  inflect.irregular 'octopus', 'octopi'

  inflect.uncountable "equipment"
end

New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may already have been loaded.

Constant Summary collapse

DEFAULT_INFLECTIONS_PROC =

Proc that is instance evaled to create the default inflections for both the model inflector and the inflector extension. rubocop:disable Metrics/BlockLength

proc do
  plural(/$/, 's')
  plural(/s$/i, 's')
  plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')
  plural(/(buffal|tomat)o$/i, '\1oes')
  plural(/([ti])um$/i, '\1a')
  plural(/sis$/i, 'ses')
  plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
  plural(/(hive)$/i, '\1s')
  plural(/([^aeiouy]|qu)y$/i, '\1ies')
  plural(/(x|ch|ss|sh)$/i, '\1es')
  plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
  plural(/([m|l])ouse$/i, '\1ice')

  singular(/s$/i, '')
  singular(/([ti])a$/i, '\1um')
  singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '\1sis')
  singular(/([^f])ves$/i, '\1fe')
  singular(/([h|t]ive)s$/i, '\1')
  singular(/([lr])ves$/i, '\1f')
  singular(/([^aeiouy]|qu)ies$/i, '\1y')
  singular(/(m)ovies$/i, '\1ovie')
  singular(/(x|ch|ss|sh)es$/i, '\1')
  singular(/([m|l])ice$/i, '\1ouse')
  singular(/buses$/i, 'bus')
  singular(/oes$/i, 'o')
  singular(/shoes$/i, 'shoe')
  singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '\1')
  singular(/(vert|ind)ices$/i, '\1ex')
  singular(/matrices$/i, 'matrix')

  irregular('person', 'people')
  irregular('man', 'men')
  irregular('child', 'children')
  irregular('sex', 'sexes')
  irregular('move', 'moves')
  irregular('quiz', 'quizzes')
  irregular('testis', 'testes')

  uncountable(%w[equipment information rice money species series fish sheep news])
end

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.plurals ⇒ Object (readonly)

An Array that stores the pluralization rules. Each rule is a 2-element array containing:

  • A regular expression pattern for matching words to pluralize

  • A substitution pattern (e.g. ‘\1es’) for transforming the match into plural form

Rules are processed in reverse order, so newer rules take precedence.



86
87
88
 
# File 'lib/core_ext/string.rb', line 86

def plurals
  @plurals
end

.singulars ⇒ Object (readonly)

An Array that stores the singularization rules. Each rule is a 2-element array containing:

  • A regular expression pattern for matching plural words

  • A substitution pattern (e.g. ‘\1y’) for transforming the match into singular form

Rules are processed in reverse order, so newer rules take precedence.



93
94
95
 
# File 'lib/core_ext/string.rb', line 93

def singulars
  @singulars
end

.uncountables ⇒ Object (readonly)

An Array of uncountable word strings that should not be inflected. These words have the same form in both singular and plural. Examples: ‘fish’, ‘money’, ‘species’



98
99
100
 
# File 'lib/core_ext/string.rb', line 98

def uncountables
  @uncountables
end

Class Method Details

.clear(scope = :all) ⇒ Array

Clear inflection rules in a given scope. If scope is not specified, all inflection rules will be cleared. Passing :plurals, :singulars, or :uncountables will clear only that specific type of rule.

Examples:

Clear all inflection rules

String.inflections.clear

Clear only plural rules

String.inflections.clear(:plurals)

Parameters:

  • scope (Symbol) (defaults to: :all) —

    The scope of rules to clear. Can be :all (default), :plurals, :singulars, or :uncountables

Returns:

  • (Array) —

    An empty array



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/core_ext/string.rb', line 115

def self.clear(scope = :all)
  case scope
  when :all
    @plurals      = []
    @singulars    = []
    @uncountables = []
  else
    instance_variable_set(:"@#{scope}", [])
  end
end

.irregular(singular, plural) ⇒ Object

Specifies a new irregular inflection rule that transforms between singular and plural forms. This method creates rules for both pluralization and singularization simultaneously. Unlike regular inflection rules, this only works with literal strings, not regexp.

Examples:

irregular('person', 'people')  # Creates rules to transform person <-> people
irregular('child', 'children') # Creates rules to transform child <-> children

Parameters:

  • singular (String) —

    The singular form of the word

  • plural (String) —

    The plural form of the word



137
138
139
140
 
# File 'lib/core_ext/string.rb', line 137

def self.irregular(singular, plural)
  plural(Regexp.new("(#{singular[0, 1]})#{singular[1..]}$", 'i'), "\\1#{plural[1..]}")
  singular(Regexp.new("(#{plural[0, 1]})#{plural[1..]}$", 'i'), "\\1#{singular[1..]}")
end

.plural(rule, replacement) ⇒ Array

Specifies a new pluralization rule to transform singular words into plural forms. Adds the rule to the beginning of the rules array so it takes precedence over existing rules.

Examples:

Add rule to pluralize words ending in ‘y’

plural(/([^aeiou])y$/i, '\1ies') # changes 'fly' to 'flies'

Parameters:

  • rule (Regexp, String) —

    Pattern to match words that should be pluralized

  • replacement (String) —

    Template for constructing the plural form, can reference captured groups from the rule pattern using \1, \2 etc.

Returns:

  • (Array) —

    The updated array of plural rules



153
154
155
 
# File 'lib/core_ext/string.rb', line 153

def self.plural(rule, replacement)
  @plurals.insert(0, [rule, replacement])
end

.singular(rule, replacement) ⇒ Array

Specifies a new singularization rule to transform plural words into singular forms. Adds the rule to the beginning of the rules array so it takes precedence over existing rules.

Examples:

Add rule to singularize words ending in ‘ies’

singular(/([^aeiou])ies$/i, '\1y') # changes 'flies' to 'fly'

Parameters:

  • rule (Regexp, String) —

    Pattern to match words that should be singularized

  • replacement (String) —

    Template for constructing the singular form, can reference captured groups from the rule pattern using \1, \2 etc.

Returns:

  • (Array) —

    The updated array of singular rules



169
170
171
 
# File 'lib/core_ext/string.rb', line 169

def self.singular(rule, replacement)
  @singulars.insert(0, [rule, replacement])
end

.uncountable(*words) ⇒ Array

Adds words that have the same singular and plural form to the uncountables list. These words will be skipped by the inflector and returned unchanged.

Examples:

Add a single uncountable word

uncountable "fish"

Add multiple uncountable words

uncountable "rice", "equipment"

Add an array of uncountable words

uncountable %w(sheep species)

Parameters:

  • words (Array<String>) —

    One or more words to mark as uncountable

Returns:

  • (Array) —

    The flattened array of all uncountable words



188
189
190
 
# File 'lib/core_ext/string.rb', line 188

def self.uncountable(*words)
  (@uncountables << words).flatten!
end