Class String
In: lib/sequel_core/core_ext.rb
lib/sequel_core/core_sql.rb
lib/sequel_model/inflector.rb
Parent: Object

Add inflection methods to String, which allows the easy transformation of words from singular to plural,class names to table names, modularized class names to ones without, and class names to foreign keys.

Methods

Included Modules

Sequel::SQL::AliasMethods Sequel::SQL::CastMethods

Classes and Modules

Module String::Inflections

Public Class methods

Yield the Inflections module if a block is given, and return the Inflections module.

[Source]

     # File lib/sequel_model/inflector.rb, line 135
135:   def self.inflections
136:     yield Inflections if block_given?
137:     Inflections
138:   end

Public Instance methods

Strings are blank if they are empty or include only whitespace

[Source]

     # File lib/sequel_core/core_ext.rb, line 166
166:   def blank?
167:     strip.empty?
168:   end
camelcase(first_letter_in_uppercase = :upper)

Alias for camelize

By default, camelize converts the string to UpperCamelCase. If the argument to camelize is set to :lower then camelize produces lowerCamelCase.

camelize will also convert ’/’ to ’::’ which is useful for converting paths to namespaces

Examples

  "active_record".camelize #=> "ActiveRecord"
  "active_record".camelize(:lower) #=> "activeRecord"
  "active_record/errors".camelize #=> "ActiveRecord::Errors"
  "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"

[Source]

     # File lib/sequel_model/inflector.rb, line 150
150:   def camelize(first_letter_in_uppercase = :upper)
151:     s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
152:     s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
153:     s
154:   end

Singularizes and camelizes the string. Also strips out all characters preceding and including a period (".").

Examples

  "egg_and_hams".classify #=> "EggAndHam"
  "post".classify #=> "Post"
  "schema.post".classify #=> "Post"

[Source]

     # File lib/sequel_model/inflector.rb, line 164
164:   def classify
165:     sub(/.*\./, '').singularize.camelize
166:   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.

Examples

  "Module".constantize #=> Module
  "Class".constantize #=> Class

[Source]

     # File lib/sequel_model/inflector.rb, line 175
175:   def constantize
176:     raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
177:     Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
178:   end

Replaces underscores with dashes in the string.

Example

  "puni_puni".dasherize #=> "puni-puni"

[Source]

     # File lib/sequel_model/inflector.rb, line 184
184:   def dasherize
185:     gsub(/_/, '-')
186:   end

Removes the module part from the expression in the string

Examples

  "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
  "Inflections".demodulize #=> "Inflections"

[Source]

     # File lib/sequel_model/inflector.rb, line 193
193:   def demodulize
194:     gsub(/^.*::/, '')
195:   end
expr()

Alias for lit

Creates a foreign key name from a class name. use_underscore sets whether the method should put ‘_’ between the name and ‘id’.

Examples

  "Message".foreign_key #=> "message_id"
  "Message".foreign_key(false) #=> "messageid"
  "Admin::Post".foreign_key #=> "post_id"

[Source]

     # File lib/sequel_model/inflector.rb, line 204
204:   def foreign_key(use_underscore = true)
205:     "#{demodulize.underscore}#{'_' if use_underscore}id"
206:   end

Capitalizes the first word and turns underscores into spaces and strips _id. Like titleize, this is meant for creating pretty output.

Examples

  "employee_salary" #=> "Employee salary"
  "author_id" #=> "Author"

[Source]

     # File lib/sequel_model/inflector.rb, line 214
214:   def humanize
215:     gsub(/_id$/, "").gsub(/_/, " ").capitalize
216:   end

Converts a string into an LiteralString, in order to override string literalization, e.g.:

  DB[:items].filter(:abc => 'def').sql #=>
    "SELECT * FROM items WHERE (abc = 'def')"

  DB[:items].filter(:abc => 'def'.lit).sql #=>
    "SELECT * FROM items WHERE (abc = def)"

[Source]

     # File lib/sequel_core/core_sql.rb, line 133
133:   def lit
134:     Sequel::LiteralString.new(self)
135:   end

Returns the plural form of the word in the string.

Examples

  "post".pluralize #=> "posts"
  "octopus".pluralize #=> "octopi"
  "sheep".pluralize #=> "sheep"
  "words".pluralize #=> "words"
  "the blue mailman".pluralize #=> "the blue mailmen"
  "CamelOctopus".pluralize #=> "CamelOctopi"

[Source]

     # File lib/sequel_model/inflector.rb, line 227
227:   def pluralize
228:     result = dup
229:     Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
230:     result
231:   end

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

Examples

  "posts".singularize #=> "post"
  "octopi".singularize #=> "octopus"
  "sheep".singluarize #=> "sheep"
  "word".singluarize #=> "word"
  "the blue mailmen".singularize #=> "the blue mailman"
  "CamelOctopi".singularize #=> "CamelOctopus"

[Source]

     # File lib/sequel_model/inflector.rb, line 242
242:   def singularize
243:     result = dup
244:     Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
245:     result
246:   end

Splits a string into separate SQL statements, removing comments and excessive white-space.

[Source]

     # File lib/sequel_core/core_sql.rb, line 140
140:   def split_sql
141:     to_sql.split(';').map {|s| s.strip}
142:   end

Underscores and pluralizes the string.

Examples

  "RawScaledScorer".tableize #=> "raw_scaled_scorers"
  "egg_and_ham".tableize #=> "egg_and_hams"
  "fancyCategory".tableize #=> "fancy_categories"

[Source]

     # File lib/sequel_model/inflector.rb, line 254
254:   def tableize
255:     underscore.pluralize
256:   end
titlecase()

Alias for titleize

Capitalizes all the words and replaces some characters in the string to create a nicer looking title. Titleize is meant for creating pretty output.

titleize is also aliased as as titlecase

Examples

  "man from the boondocks".titleize #=> "Man From The Boondocks"
  "x-men: the last stand".titleize #=> "X Men: The Last Stand"

[Source]

     # File lib/sequel_model/inflector.rb, line 266
266:   def titleize
267:     underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
268:   end

Returns a Blob that holds the same data as this string. Blobs provide proper escaping of binary data.

[Source]

     # File lib/sequel_core/core_sql.rb, line 152
152:   def to_blob
153:     ::Sequel::SQL::Blob.new self
154:   end

Converts a string into a Date object.

[Source]

     # File lib/sequel_core/core_ext.rb, line 171
171:   def to_date
172:     begin
173:       Date.parse(self, Sequel.convert_two_digit_years)
174:     rescue => e
175:       raise Sequel::Error::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
176:     end
177:   end

Converts a string into a DateTime object.

[Source]

     # File lib/sequel_core/core_ext.rb, line 180
180:   def to_datetime
181:     begin
182:       DateTime.parse(self, Sequel.convert_two_digit_years)
183:     rescue => e
184:       raise Sequel::Error::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
185:     end
186:   end

Converts a string into a Time or DateTime object, depending on the value of Sequel.datetime_class

[Source]

     # File lib/sequel_core/core_ext.rb, line 190
190:   def to_sequel_time
191:     begin
192:       if Sequel.datetime_class == DateTime
193:         DateTime.parse(self, Sequel.convert_two_digit_years)
194:       else
195:         Sequel.datetime_class.parse(self)
196:       end
197:     rescue => e
198:       raise Sequel::Error::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
199:     end
200:   end

Converts a string into an SQL string by removing comments. See also Array#to_sql.

[Source]

     # File lib/sequel_core/core_sql.rb, line 146
146:   def to_sql
147:     split("\n").to_sql
148:   end

Converts a string into a Time object.

[Source]

     # File lib/sequel_core/core_ext.rb, line 203
203:   def to_time
204:     begin
205:       Time.parse(self)
206:     rescue => e
207:       raise Sequel::Error::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
208:     end
209:   end

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

Examples

  "ActiveRecord".underscore #=> "active_record"
  "ActiveRecord::Errors".underscore #=> active_record/errors

[Source]

     # File lib/sequel_model/inflector.rb, line 277
277:   def underscore
278:     gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
279:       gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
280:   end

[Validate]