String

Sequel extends String to add methods to implement the SQL DSL.

The inflector extension adds inflection instance 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. It exists for backwards compatibility to legacy Sequel code.

To load the extension:

Sequel.extension :inflector

The string_date_time extension provides String instance methods for converting the strings to a date (e.g. #to_date), allowing for backwards compatibility with legacy Sequel code.

To load the extension:

Sequel.extension :string_date_time

Methods

Public Class

inflections

Public Instance

blank?
camelize
classify
constantize
dasherize
demodulize
foreign_key
humanize
lit
pluralize
singularize
tableize
titleize
to_date
to_datetime
to_sequel_blob
to_sequel_time
to_time
underscore

Included modules

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

Classes and Modules

String::Inflections

Public Instance Aliases

camelcase	->	camelize
titlecase	->	titleize

Public Class methods

inflections ()

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

# File lib/sequel/extensions/inflector.rb, line 100
def self.inflections
  yield Inflections if block_given?
  Inflections
end

Public Instance methods

blank? ()

Strings are blank if they are empty or include only whitespace

# File lib/sequel/extensions/blank.rb, line 37
def blank?
  strip.empty?
end

camelize (first_letter_in_uppercase = :upper)

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"

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

classify ()

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"

# File lib/sequel/extensions/inflector.rb, line 129
def classify
  sub(/.*\./, '').singularize.camelize
end

constantize ()

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

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

dasherize ()

Replaces underscores with dashes in the string.

Example

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

# File lib/sequel/extensions/inflector.rb, line 149
def dasherize
  gsub(/_/, '-')
end

demodulize ()

Removes the module part from the expression in the string

Examples

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

# File lib/sequel/extensions/inflector.rb, line 158
def demodulize
  gsub(/^.*::/, '')
end

foreign_key (use_underscore = true)

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"

# File lib/sequel/extensions/inflector.rb, line 169
def foreign_key(use_underscore = true)
  "#{demodulize.underscore}#{'_' if use_underscore}id"
end

humanize ()

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"

# File lib/sequel/extensions/inflector.rb, line 179
def humanize
  gsub(/_id$/, "").gsub(/_/, " ").capitalize
end

lit (*args)

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"

# File lib/sequel/extensions/core_extensions.rb, line 187
def lit(*args)
  args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
end

pluralize ()

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"

# File lib/sequel/extensions/inflector.rb, line 192
def pluralize
  result = dup
  Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end

singularize ()

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"

# File lib/sequel/extensions/inflector.rb, line 207
def singularize
  result = dup
  Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end

tableize ()

Underscores and pluralizes the string.

Examples

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

# File lib/sequel/extensions/inflector.rb, line 219
def tableize
  underscore.pluralize
end

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"

# File lib/sequel/extensions/inflector.rb, line 231
def titleize
  underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
end

to_date ()

Converts a string into a Date object.

# File lib/sequel/extensions/string_date_time.rb, line 11
def to_date
  begin
    Date.parse(self, Sequel.convert_two_digit_years)
  rescue => e
    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
  end
end

to_datetime ()

Converts a string into a DateTime object.

# File lib/sequel/extensions/string_date_time.rb, line 20
def to_datetime
  begin
    DateTime.parse(self, Sequel.convert_two_digit_years)
  rescue => e
    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
  end
end

to_sequel_blob ()

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

# File lib/sequel/extensions/core_extensions.rb, line 193
def to_sequel_blob
  ::Sequel::SQL::Blob.new(self)
end

to_sequel_time ()

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

# File lib/sequel/extensions/string_date_time.rb, line 30
def to_sequel_time
  begin
    if Sequel.datetime_class == DateTime
      DateTime.parse(self, Sequel.convert_two_digit_years)
    else
      Sequel.datetime_class.parse(self)
    end
  rescue => e
    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
  end
end

to_time ()

Converts a string into a Time object.

# File lib/sequel/extensions/string_date_time.rb, line 43
def to_time
  begin
    Time.parse(self)
  rescue => e
    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
  end
end

underscore ()

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

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