class String

  1. lib/sequel/extensions/blank.rb
  2. lib/sequel/extensions/core_extensions.rb
  3. lib/sequel/extensions/inflector.rb
  4. lib/sequel/extensions/string_date_time.rb
  5. show all
Superclass: Object

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

Included modules

  1. Sequel::SQL::AliasMethods
  2. Sequel::SQL::CastMethods

Classes and Modules

  1. 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.

[show source]
    # File lib/sequel/extensions/inflector.rb
104 def self.inflections
105   yield Inflections if defined?(yield)
106   Inflections
107 end

Public Instance methods

blank?()

Strings are blank if they are empty or include only whitespace

[show source]
   # File lib/sequel/extensions/blank.rb
47 def blank?
48   strip.empty?
49 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"
[show source]
    # File lib/sequel/extensions/inflector.rb
127 def camelize(first_letter_in_uppercase = :upper)
128   s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
129   s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
130   s
131 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"
[show source]
    # File lib/sequel/extensions/inflector.rb
141 def classify
142   sub(/.*\./, '').singularize.camelize
143 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
[show source]
    # File lib/sequel/extensions/inflector.rb
152 def constantize
153   raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
154   Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
155 end
dasherize()

Replaces underscores with dashes in the string.

Example

"puni_puni".dasherize #=> "puni-puni"
[show source]
    # File lib/sequel/extensions/inflector.rb
161 def dasherize
162   gsub('_', '-')
163 end
demodulize()

Removes the module part from the expression in the string

Examples

"ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
"Inflections".demodulize #=> "Inflections"
[show source]
    # File lib/sequel/extensions/inflector.rb
170 def demodulize
171   gsub(/^.*::/, '')
172 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"
[show source]
    # File lib/sequel/extensions/inflector.rb
181 def foreign_key(use_underscore = true)
182   "#{demodulize.underscore}#{'_' if use_underscore}id"
183 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"
[show source]
    # File lib/sequel/extensions/inflector.rb
191 def humanize
192   gsub(/_id$/, "").gsub('_', " ").capitalize
193 end
lit(*args)

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"
[show source]
    # 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()

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"
[show source]
    # File lib/sequel/extensions/inflector.rb
204 def pluralize
205   result = dup
206   Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
207   result
208 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"
[show source]
    # File lib/sequel/extensions/inflector.rb
219 def singularize
220   result = dup
221   Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
222   result
223 end
tableize()

Underscores and pluralizes the string.

Examples

"RawScaledScorer".tableize #=> "raw_scaled_scorers"
"egg_and_ham".tableize #=> "egg_and_hams"
"fancyCategory".tableize #=> "fancy_categories"
[show source]
    # File lib/sequel/extensions/inflector.rb
231 def tableize
232   underscore.pluralize
233 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"
[show source]
    # File lib/sequel/extensions/inflector.rb
243 def titleize
244   underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
245 end
to_date()

Converts a string into a Date object.

[show source]
   # 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()

Converts a string into a DateTime object.

[show source]
   # 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()

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

[show source]
    # File lib/sequel/extensions/core_extensions.rb
190 def to_sequel_blob
191   ::Sequel::SQL::Blob.new(self)
192 end
to_sequel_time()

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

[show source]
   # 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()

Converts a string into a Time object.

[show source]
   # 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()

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
[show source]
    # File lib/sequel/extensions/inflector.rb
254 def underscore
255   gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
256     gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
257 end