Class: String

Inherits:
Object show all
Includes:
Sequel::SQL::AliasMethods, Sequel::SQL::CastMethods
Defined in:
lib/sequel/extensions/inflector.rb,
lib/sequel/extensions/blank.rb,
lib/sequel/extensions/core_extensions.rb,
lib/sequel/extensions/string_date_time.rb

Overview

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.

These methods calls parse on the related class, and as such, can result in denial of service in older versions of Ruby for large untrusted input, and raise exceptions in newer versions of Ruby.

To load the extension:

Sequel.extension :string_date_time

Defined Under Namespace

Modules: Inflections

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Sequel::SQL::CastMethods

#cast, #cast_numeric, #cast_string

Methods included from Sequel::SQL::AliasMethods

#as

Class Method Details

.inflections {|Inflections| ... } ⇒ Object

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

Yields:



104
105
106
107
 
# File 'lib/sequel/extensions/inflector.rb', line 104

def self.inflections
  yield Inflections if defined?(yield)
  Inflections
end

Instance Method Details

#blank? ⇒ Boolean

Strings are blank if they are empty or include only whitespace

Returns:

  • (Boolean) 


47
48
49
 
# File 'lib/sequel/extensions/blank.rb', line 47

def blank?
  strip.empty?
end

#camelize(first_letter_in_uppercase = :upper) ⇒ Object Also known as: camelcase

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"



127
128
129
130
131
 
# File 'lib/sequel/extensions/inflector.rb', line 127

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 ⇒ Object

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"



141
142
143
 
# File 'lib/sequel/extensions/inflector.rb', line 141

def classify
  sub(/.*\./, '').singularize.camelize
end

#constantize ⇒ Object

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

Raises:

  • (NameError) 


152
153
154
155
 
# File 'lib/sequel/extensions/inflector.rb', line 152

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 ⇒ Object

Replaces underscores with dashes in the string.

Example

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



161
162
163
 
# File 'lib/sequel/extensions/inflector.rb', line 161

def dasherize
  gsub('_', '-')
end

#demodulize ⇒ Object

Removes the module part from the expression in the string

Examples

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



170
171
172
 
# File 'lib/sequel/extensions/inflector.rb', line 170

def demodulize
  gsub(/^.*::/, '')
end

#foreign_key(use_underscore = true) ⇒ Object

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"



181
182
183
 
# File 'lib/sequel/extensions/inflector.rb', line 181

def foreign_key(use_underscore = true)
  "#{demodulize.underscore}#{'_' if use_underscore}id"
end

#humanize ⇒ Object

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"



191
192
193
 
# File 'lib/sequel/extensions/inflector.rb', line 191

def humanize
  gsub(/_id$/, "").gsub('_', " ").capitalize
end

#lit(*args) ⇒ Object

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"



184
185
186
 
# File 'lib/sequel/extensions/core_extensions.rb', line 184

def lit(*args)
  args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
end

#pluralize ⇒ Object

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"



204
205
206
207
208
 
# File 'lib/sequel/extensions/inflector.rb', line 204

def pluralize
  result = dup
  Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end

#singularize ⇒ Object

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"



219
220
221
222
223
 
# File 'lib/sequel/extensions/inflector.rb', line 219

def singularize
  result = dup
  Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
  result
end

#tableize ⇒ Object

Underscores and pluralizes the string.

Examples

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



231
232
233
 
# File 'lib/sequel/extensions/inflector.rb', line 231

def tableize
  underscore.pluralize
end

#titleize ⇒ Object Also known as: titlecase

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"



243
244
245
 
# File 'lib/sequel/extensions/inflector.rb', line 243

def titleize
  underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
end

#to_date ⇒ Object

Converts a string into a Date object.



17
18
19
20
21
 
# File 'lib/sequel/extensions/string_date_time.rb', line 17

def to_date
  Date.parse(self, Sequel.convert_two_digit_years)
rescue => e
  raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
end

#to_datetime ⇒ Object

Converts a string into a DateTime object.



24
25
26
27
28
 
# File 'lib/sequel/extensions/string_date_time.rb', line 24

def to_datetime
  DateTime.parse(self, Sequel.convert_two_digit_years)
rescue => e
  raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
end

#to_sequel_blob ⇒ Object

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



190
191
192
 
# File 'lib/sequel/extensions/core_extensions.rb', line 190

def to_sequel_blob
  ::Sequel::SQL::Blob.new(self)
end

#to_sequel_time ⇒ Object

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



32
33
34
35
36
37
38
39
40
 
# File 'lib/sequel/extensions/string_date_time.rb', line 32

def to_sequel_time
  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

#to_time ⇒ Object

Converts a string into a Time object.



43
44
45
46
47
 
# File 'lib/sequel/extensions/string_date_time.rb', line 43

def to_time
  Time.parse(self)
rescue => e
  raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
end

#underscore ⇒ Object

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



254
255
256
257
 
# File 'lib/sequel/extensions/inflector.rb', line 254

def underscore
  gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
end