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
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
Strings are blank if they are empty or include only whitespace
# File lib/sequel/extensions/blank.rb 45 def blank? 46 strip.empty? 47 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"
# File lib/sequel/extensions/inflector.rb 125 def camelize(first_letter_in_uppercase = :upper) 126 s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase} 127 s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper 128 s 129 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"
# File lib/sequel/extensions/inflector.rb 139 def classify 140 sub(/.*\./, '').singularize.camelize 141 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
# File lib/sequel/extensions/inflector.rb 150 def constantize 151 raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self) 152 Object.module_eval("::#{m[1]}", __FILE__, __LINE__) 153 end
Replaces underscores with dashes in the string.
Example
"puni_puni".dasherize #=> "puni-puni"
# File lib/sequel/extensions/inflector.rb 159 def dasherize 160 gsub('_', '-') 161 end
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 168 def demodulize 169 gsub(/^.*::/, '') 170 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"
# File lib/sequel/extensions/inflector.rb 179 def foreign_key(use_underscore = true) 180 "#{demodulize.underscore}#{'_' if use_underscore}id" 181 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"
# File lib/sequel/extensions/inflector.rb 189 def humanize 190 gsub(/_id$/, "").gsub('_', " ").capitalize 191 end
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
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 202 def pluralize 203 result = dup 204 Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase) 205 result 206 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"
# File lib/sequel/extensions/inflector.rb 217 def singularize 218 result = dup 219 Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase) 220 result 221 end
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 229 def tableize 230 underscore.pluralize 231 end
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 241 def titleize 242 underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase} 243 end
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
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
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
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
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
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 252 def underscore 253 gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2'). 254 gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase 255 end