Module: Padrino::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 = 
/(^|_)(.)/
CAMELIZE_MODULE_REGEXP = 
%r{/(.?)}
DASH = 
'-'.freeze
DEMODULIZE_CONVERT_REGEXP = 
/^.*::/
EMPTY_STRING = 
''.freeze
SLASH = 
'/'.freeze
VALID_CONSTANT_NAME_REGEXP = 
/\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/
UNDERSCORE = 
'_'.freeze
UNDERSCORE_CONVERT_REGEXP1 = 
/([A-Z]+)([A-Z][a-z])/
UNDERSCORE_CONVERT_REGEXP2 = 
/([a-z\d])([A-Z])/
UNDERSCORE_CONVERT_REPLACE = 
'\1_\2'.freeze
UNDERSCORE_MODULE_REGEXP = 
/::/

Class Attribute Summary collapse

Class 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

.camelize(str) ⇒ Object

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



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

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

.classify(str) ⇒ Object

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



176
177
178
179
180
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 176

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

.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

.constantize(str) ⇒ 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) 


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

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

.demodulize(str) ⇒ Object

Removes the module part from the expression in the string



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

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

.humanize(str) ⇒ Object

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



167
168
169
170
171
 
# File 'padrino-support/lib/padrino-support/inflections.rb', line 167

def humanize(str)
  str = str.to_s
  return str.humanize if str.respond_to?(:humanize)
  str.gsub(/_id$/, '').tr('_', ' ').capitalize
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..]}$", 'i'), "\\1#{plural[1..]}")
  singular(Regexp.new("(#{plural[0, 1]})#{plural[1..]}$", 'i'), "\\1#{singular[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

.pluralize(str) ⇒ Object

Returns the plural form of the word in the string.



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

def pluralize(str)
  str = str.to_s
  return str.pluralize if str.respond_to?(:pluralize)
  result = str.dup
  Inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } unless Inflections.uncountables.include?(str.downcase)
  result
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

.singularize(str) ⇒ Object

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



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

def singularize(str)
  str = str.to_s
  return str.singularize if str.respond_to?(:singularize)
  result = str.dup
  Inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) } unless Inflections.uncountables.include?(str.downcase)
  result
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

.underscore(str) ⇒ Object

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



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

def underscore(str)
  str = str.to_s
  return str.underscore if str.respond_to?(:underscore)

  str.gsub(UNDERSCORE_MODULE_REGEXP, SLASH)
     .gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE)
     .gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE)
     .tr(DASH, UNDERSCORE)
     .downcase
end