Module: Waves::Inflect::InflectorMethods

Included in:
Layers::Inflect::English::Rules
Defined in:
lib/utilities/inflect.rb

Instance Method Summary collapse

Instance Method Details

#plural(word) ⇒ Object

Convert an English word from singular to plurel.

"boy".plural     #=> boys
"tomato".plural  #=> tomatoes



97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/utilities/inflect.rb', line 97

def plural(word)
  if result = plural_of[word]
    return result.dup
  end
  #return self.dup if /s$/ =~ self # ???
  result = word.dup
  pluralization_rules.each do |(match, replacement)|
    break if result.gsub!(match, replacement)
  end
  return result
end

#plural_of ⇒ Object 



67
68
69
 
# File 'lib/utilities/inflect.rb', line 67

def plural_of
  @plural_of ||= {}
end

#plural_rule(singular, plural) ⇒ Object

Define a plurualization rule.



42
43
44
 
# File 'lib/utilities/inflect.rb', line 42

def plural_rule(singular, plural)
  (@plural_rules ||= []) << [singular, plural]
end

#plural_word(singular, plural) ⇒ Object

Define a pluralization exception.



25
26
27
28
 
# File 'lib/utilities/inflect.rb', line 25

def plural_word(singular, plural)
  @plural_of ||= {}
  @plural_of[singular] = plural
end

#pluralization_rules ⇒ Object

Read prepared pluralization rules.



57
58
59
60
61
62
63
64
 
# File 'lib/utilities/inflect.rb', line 57

def pluralization_rules
  @plural_rules ||= []
  return @pluralization_rules if @pluralization_rules
  sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
  @pluralization_rules = sorted.collect do |s, p|
    [ /#{s}$/, "#{p}" ]
  end
end

#rule(singular, plural) ⇒ Object

Define a general rule.



31
32
33
34
 
# File 'lib/utilities/inflect.rb', line 31

def rule(singular, plural)
  singular_rule(singular, plural)
  plural_rule(singular, plural)
end

#singular(word) ⇒ Object

Convert an English word from plural to singular.

"boys".singular      #=> boy
"tomatoes".singular  #=> tomato



81
82
83
84
85
86
87
88
89
90
 
# File 'lib/utilities/inflect.rb', line 81

def singular(word)
  if result = singular_of[word]
    return result.dup
  end
  result = word.dup
  singularization_rules.each do |(match, replacement)|
    break if result.gsub!(match, replacement)
  end
  return result
end

#singular_of ⇒ Object 



72
73
74
 
# File 'lib/utilities/inflect.rb', line 72

def singular_of
  @singular_of ||= {}
end

#singular_rule(singular, plural) ⇒ Object

Define a singularization rule.



37
38
39
 
# File 'lib/utilities/inflect.rb', line 37

def singular_rule(singular, plural)
  (@singular_rules ||= []) << [singular, plural]
end

#singular_word(singular, plural) ⇒ Object

Define a singularization exception.



19
20
21
22
 
# File 'lib/utilities/inflect.rb', line 19

def singular_word(singular, plural)
  @singular_of ||= {}
  @singular_of[plural] = singular
end

#singularization_rules ⇒ Object

Read prepared singularization rules.



47
48
49
50
51
52
53
54
 
# File 'lib/utilities/inflect.rb', line 47

def singularization_rules
  @singular_rules ||= []
  return @singularization_rules if @singularization_rules
  sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
  @singularization_rules = sorted.collect do |s, p|
    [ /#{p}$/, "#{s}" ]
  end
end

#word(singular, plural = nil) ⇒ Object

Define a general exception.



12
13
14
15
16
 
# File 'lib/utilities/inflect.rb', line 12

def word(singular, plural=nil)
  plural = singular unless plural
  singular_word(singular, plural)
  plural_word(singular, plural)
end