Module: Padrino::Inflections

Extended by:
Inflections
Included in:
Inflections
Defined in:
padrino-support/lib/padrino-support/inflections.rb

Overview

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

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

CAMELIZE_CONVERT_REGEXP = 
/(^|_)(.)/.freeze
CAMELIZE_MODULE_REGEXP = 
/\/(.?)/.freeze
DASH = 
'-'.freeze
DEMODULIZE_CONVERT_REGEXP = 
/^.*::/.freeze
EMPTY_STRING = 
''.freeze
SLASH = 
'/'.freeze
VALID_CONSTANT_NAME_REGEXP = 
/\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
UNDERSCORE = 
'_'.freeze
UNDERSCORE_CONVERT_REGEXP1 = 
/([A-Z]+)([A-Z][a-z])/.freeze
UNDERSCORE_CONVERT_REGEXP2 = 
/([a-z\d])([A-Z])/.freeze
UNDERSCORE_CONVERT_REPLACE = 
'\1_\2'.freeze
UNDERSCORE_MODULE_REGEXP = 
/::/.freeze

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Class Attribute Details

.plurals ⇒ Object (readonly)

Array of two element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.



42
43
44
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 42

def plurals
  @plurals
end

.singulars ⇒ Object (readonly)

Array of two element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.



45
46
47
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 45

def singulars
  @singulars
end

.uncountables ⇒ Object (readonly)

Array of strings for words were the singular form is the same as the plural form



48
49
50
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 48

def uncountables
  @uncountables
end

Class Method Details

.clear(scope = :all) ⇒ Object

Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type, the options are: :plurals, :singulars, :uncountables

Examples:

clear :all
clear :plurals



57
58
59
60
61
62
63
64
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 57

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 that applies to both pluralization and singularization at the same time. This can only be used for strings, not regular expressions. You simply pass the irregular in singular and plural form.

Examples:

irregular 'octopus', 'octopi'
irregular 'person', 'people'



72
73
74
75
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 72

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

.plural(rule, replacement) ⇒ Object

Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression. The replacement should always be a string that may include references to the matched data from the rule.

Example:

plural(/(x|ch|ss|sh)$/i, '\1es')



82
83
84
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 82

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

.singular(rule, replacement) ⇒ Object

Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression. The replacement should always be a string that may include references to the matched data from the rule.

Example:

singular(/([^aeiouy]|qu)ies$/i, '\1y')



91
92
93
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 91

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

.uncountable(*words) ⇒ Object

Add uncountable words that shouldn’t be attempted inflected.

Examples:

uncountable "money"
uncountable "money", "information"
uncountable %w( money information rice )



101
102
103
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 101

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

Instance Method Details

#camelize(s) ⇒ Object

Convert the given string to CamelCase. Will also convert ‘/’ to ‘::’ which is useful for converting paths to namespaces.



110
111
112
113
114
115
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 110

def camelize(s)
  s = s.to_s
  return s.camelize if s.respond_to?(:camelize)
  s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
  s
end

#classify(s) ⇒ Object

Create a class name from a plural table name like Rails does for table names to models.



173
174
175
176
177
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 173

def classify(s)
  s = s.to_s
  return s.classify if s.respond_to?(:classify)
  camelize(singularize(s.sub(/.*\./, '')))
end

#constantize(s) ⇒ Object

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.

Raises:

  • (NameError) 


120
121
122
123
124
125
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 120

def constantize(s)
  s = s.to_s
  return s.constantize if s.respond_to?(:constantize)
  raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
  Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
end

#demodulize(s) ⇒ Object

Removes the module part from the expression in the string



128
129
130
131
132
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 128

def demodulize(s)
  s = s.to_s
  return s.demodulize if s.respond_to?(:demodulize)
  s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
end

#humanize(s) ⇒ Object

Capitalizes the first word, turns underscores into spaces, and strips a trailing ‘_id’ if present.



164
165
166
167
168
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 164

def humanize(s)
  s = s.to_s
  return s.humanize if s.respond_to?(:humanize)
  s.gsub(/_id$/, '').tr('_', ' ').capitalize
end

#pluralize(s) ⇒ Object

Returns the plural form of the word in the string.



135
136
137
138
139
140
141
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 135

def pluralize(s)
  s = s.to_s
  return s.pluralize if s.respond_to?(:pluralize)
  result = s.dup
  Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
  result
end

#singularize(s) ⇒ Object

The reverse of pluralize, returns the singular form of a word in a string.



144
145
146
147
148
149
150
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 144

def singularize(s)
  s = s.to_s
  return s.singularize if s.respond_to?(:singularize)
  result = s.dup
  Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
  result
end

#underscore(s) ⇒ Object

The reverse of camelize. Makes an underscored form from the expression in the string. Also changes ‘::’ to ‘/’ to convert namespaces to paths.



154
155
156
157
158
159
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 154

def underscore(s)
  s = s.to_s
  return s.underscore if s.respond_to?(:underscore)
  s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
    gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
end