Class String
In: lib/sequel/extensions/string_date_time.rb
lib/sequel/extensions/inflector.rb
lib/sequel/extensions/blank.rb
lib/sequel/core_sql.rb
lib/sequel/model/deprecated_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 Module

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/extensions/inflector.rb, line 142
142:   def self.inflections
143:     yield Inflections if block_given?
144:     Inflections
145:   end

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

[Source]

     # File lib/sequel/model/deprecated_inflector.rb, line 150
150:   def self.inflections
151:     Sequel::Deprecation.deprecate('String.inflections', 'require "sequel/extensions/inflector" first')
152:     yield Inflections if block_given?
153:     Inflections
154:   end

Public Instance methods

Strings are blank if they are empty or include only whitespace

[Source]

    # File lib/sequel/extensions/blank.rb, line 32
32:   def blank?
33:     strip.empty?
34:   end
camelcase(first_letter_in_uppercase = :upper)

Alias for camelize

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/deprecated_inflector.rb, line 168
168:       def camelize(first_letter_in_uppercase = :upper)
169:         Sequel::Deprecation.deprecate('String#camelize', 'require "sequel/extensions/inflector" first')
170:         s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
171:         s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
172:         s
173:       end

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/extensions/inflector.rb, line 157
157:   def camelize(first_letter_in_uppercase = :upper)
158:     s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
159:     s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
160:     s
161:   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/extensions/inflector.rb, line 171
171:   def classify
172:     sub(/.*\./, '').singularize.camelize
173:   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/extensions/inflector.rb, line 182
182:   def constantize
183:     raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
184:     Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
185:   end

Replaces underscores with dashes in the string.

Example

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

[Source]

     # File lib/sequel/extensions/inflector.rb, line 191
191:   def dasherize
192:     gsub(/_/, '-')
193:   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/extensions/inflector.rb, line 200
200:   def demodulize
201:     gsub(/^.*::/, '')
202:   end

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/extensions/inflector.rb, line 211
211:   def foreign_key(use_underscore = true)
212:     "#{demodulize.underscore}#{'_' if use_underscore}id"
213:   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/extensions/inflector.rb, line 221
221:   def humanize
222:     gsub(/_id$/, "").gsub(/_/, " ").capitalize
223:   end

Converts a string into a Sequel::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)"

You can also provide arguments, to create a Sequel::SQL::PlaceholderLiteralString:

   DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}.sql #=>
     "SELECT count(DISTINCT a) FROM items"

[Source]

     # File lib/sequel/core_sql.rb, line 192
192:   def lit(*args)
193:     args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
194:   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/extensions/inflector.rb, line 234
234:   def pluralize
235:     result = dup
236:     Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
237:     result
238:   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/extensions/inflector.rb, line 249
249:   def singularize
250:     result = dup
251:     Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
252:     result
253:   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/extensions/inflector.rb, line 261
261:   def tableize
262:     underscore.pluralize
263:   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/extensions/inflector.rb, line 273
273:   def titleize
274:     underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
275:   end

Converts a string into a Date object.

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 8
 8:   def to_date
 9:     begin
10:       Date.parse(self, Sequel.convert_two_digit_years)
11:     rescue => e
12:       raise Sequel::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
13:     end
14:   end

Converts a string into a DateTime object.

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 17
17:   def to_datetime
18:     begin
19:       DateTime.parse(self, Sequel.convert_two_digit_years)
20:     rescue => e
21:       raise Sequel::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
22:     end
23:   end

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

[Source]

     # File lib/sequel/core_sql.rb, line 198
198:   def to_sequel_blob
199:     ::Sequel::SQL::Blob.new(self)
200:   end

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

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 27
27:   def to_sequel_time
28:     begin
29:       if Sequel.datetime_class == DateTime
30:         DateTime.parse(self, Sequel.convert_two_digit_years)
31:       else
32:         Sequel.datetime_class.parse(self)
33:       end
34:     rescue => e
35:       raise Sequel::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
36:     end
37:   end

Converts a string into a Time object.

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 40
40:   def to_time
41:     begin
42:       Time.parse(self)
43:     rescue => e
44:       raise Sequel::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
45:     end
46:   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/extensions/inflector.rb, line 284
284:   def underscore
285:     gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
286:       gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
287:   end

[Validate]