class 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

Related module: String::Inflections

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

To load the extension:

Sequel.extension :string_date_time

Public Class Methods

inflections() { |Inflections| ... } click to toggle source

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

    # File lib/sequel/extensions/inflector.rb
104 def self.inflections
105   yield Inflections if block_given?
106   Inflections
107 end

Public Instance Methods

blank?() click to toggle source

Strings are blank if they are empty or include only whitespace

   # File lib/sequel/extensions/blank.rb
39 def blank?
40   strip.empty?
41 end
camelcase(first_letter_in_uppercase = :upper)
Alias for: camelize
camelize(first_letter_in_uppercase = :upper) click to toggle source

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
119 def camelize(first_letter_in_uppercase = :upper)
120   s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
121   s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
122   s
123 end
Also aliased as: camelcase
classify() click to toggle source

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
133 def classify
134   sub(/.*\./, '').singularize.camelize
135 end
constantize() click to toggle source

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
144 def constantize
145   raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
146   Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
147 end
dasherize() click to toggle source

Replaces underscores with dashes in the string.

Example

"puni_puni".dasherize #=> "puni-puni"
    # File lib/sequel/extensions/inflector.rb
153 def dasherize
154   gsub('_', '-')
155 end
demodulize() click to toggle source

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
162 def demodulize
163   gsub(/^.*::/, '')
164 end
foreign_key(use_underscore = true) click to toggle source

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
173 def foreign_key(use_underscore = true)
174   "#{demodulize.underscore}#{'_' if use_underscore}id"
175 end
humanize() click to toggle source

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
183 def humanize
184   gsub(/_id$/, "").gsub('_', " ").capitalize
185 end
lit(*args) click to toggle source

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

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

DB[:items].where(abc: 'def'.lit)
# "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))}
# "SELECT count(DISTINCT a) FROM items"
    # File lib/sequel/extensions/core_extensions.rb
184 def lit(*args)
185   args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
186 end
pluralize() click to toggle source

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
196 def pluralize
197   result = dup
198   Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
199   result
200 end
singularize() click to toggle source

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
211 def singularize
212   result = dup
213   Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
214   result
215 end
tableize() click to toggle source

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
223 def tableize
224   underscore.pluralize
225 end
titlecase()
Alias for: titleize
titleize() click to toggle source

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
235 def titleize
236   underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
237 end
Also aliased as: titlecase
to_date() click to toggle source

Converts a string into a Date object.

   # File lib/sequel/extensions/string_date_time.rb
13 def to_date
14   begin
15     Date.parse(self, Sequel.convert_two_digit_years)
16   rescue => e
17     raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
18   end
19 end
to_datetime() click to toggle source

Converts a string into a DateTime object.

   # File lib/sequel/extensions/string_date_time.rb
22 def to_datetime
23   begin
24     DateTime.parse(self, Sequel.convert_two_digit_years)
25   rescue => e
26     raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
27   end
28 end
to_sequel_blob() click to toggle source

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
190 def to_sequel_blob
191   ::Sequel::SQL::Blob.new(self)
192 end
to_sequel_time() click to toggle source

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
32 def to_sequel_time
33   begin
34     if Sequel.datetime_class == DateTime
35       DateTime.parse(self, Sequel.convert_two_digit_years)
36     else
37       Sequel.datetime_class.parse(self)
38     end
39   rescue => e
40     raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
41   end
42 end
to_time() click to toggle source

Converts a string into a Time object.

   # File lib/sequel/extensions/string_date_time.rb
45 def to_time
46   begin
47     Time.parse(self)
48   rescue => e
49     raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
50   end
51 end
underscore() click to toggle source

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
246 def underscore
247   gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
248     gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
249 end