Class String
In: lib/sequel/core_sql.rb
lib/sequel/extensions/string_date_time.rb
lib/sequel/extensions/blank.rb
lib/sequel/extensions/inflector.rb
lib/sequel/extensions/sql_expr.rb
Parent: Object

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.

Methods

Included Modules

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

Classes and Modules

Module String::Inflections

Public Class methods

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

[Source]

    # File lib/sequel/extensions/inflector.rb, line 96
96:   def self.inflections
97:     yield Inflections if block_given?
98:     Inflections
99:   end

Public Instance methods

Strings are blank if they are empty or include only whitespace

[Source]

    # File lib/sequel/extensions/blank.rb, line 33
33:   def blank?
34:     strip.empty?
35:   end
camelcase(first_letter_in_uppercase = :upper)

Alias for camelize

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"

[Source]

     # File lib/sequel/extensions/inflector.rb, line 111
111:   def camelize(first_letter_in_uppercase = :upper)
112:     s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
113:     s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
114:     s
115:   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"

[Source]

     # File lib/sequel/extensions/inflector.rb, line 125
125:   def classify
126:     sub(/.*\./, '').singularize.camelize
127:   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

[Source]

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

Replaces underscores with dashes in the string.

Example

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

[Source]

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

Removes the module part from the expression in the string

Examples

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

[Source]

     # File lib/sequel/extensions/inflector.rb, line 154
154:   def demodulize
155:     gsub(/^.*::/, '')
156:   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"

[Source]

     # File lib/sequel/extensions/inflector.rb, line 165
165:   def foreign_key(use_underscore = true)
166:     "#{demodulize.underscore}#{'_' if use_underscore}id"
167:   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"

[Source]

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

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"

[Source]

     # File lib/sequel/core_sql.rb, line 192
192:   def lit(*args)
193:     args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
194:   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"

[Source]

     # File lib/sequel/extensions/inflector.rb, line 188
188:   def pluralize
189:     result = dup
190:     Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
191:     result
192:   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"

[Source]

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

Returns a copy of the object wrapped in a Sequel::SQL::StringExpression, allowing easy use of Sequel‘s DSL:

  "a".sql_expr + :a  # 'a' || a

[Source]

     # File lib/sequel/extensions/sql_expr.rb, line 107
107:   def sql_expr
108:     Sequel::SQL::StringExpression.new(:NOOP, self)
109:   end

Underscores and pluralizes the string.

Examples

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

[Source]

     # File lib/sequel/extensions/inflector.rb, line 215
215:   def tableize
216:     underscore.pluralize
217:   end
titlecase()

Alias for 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"

[Source]

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

Converts a string into a Date object.

[Source]

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

Converts a string into a DateTime object.

[Source]

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

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

[Source]

     # File lib/sequel/core_sql.rb, line 198
198:   def to_sequel_blob
199:     ::Sequel::SQL::Blob.new(self)
200:   end

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

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 26
26:   def to_sequel_time
27:     begin
28:       if Sequel.datetime_class == DateTime
29:         DateTime.parse(self, Sequel.convert_two_digit_years)
30:       else
31:         Sequel.datetime_class.parse(self)
32:       end
33:     rescue => e
34:       raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
35:     end
36:   end

Converts a string into a Time object.

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 39
39:   def to_time
40:     begin
41:       Time.parse(self)
42:     rescue => e
43:       raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
44:     end
45:   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

[Source]

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

[Validate]