Class String
In: lib/sequel/extensions/string_date_time.rb
lib/sequel/extensions/core_extensions.rb
lib/sequel/extensions/inflector.rb
lib/sequel/extensions/blank.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.

To load the extension:

  Sequel.extension :inflector

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 100
100:   def self.inflections
101:     yield Inflections if block_given?
102:     Inflections
103:   end

Public Instance methods

Strings are blank if they are empty or include only whitespace

[Source]

    # File lib/sequel/extensions/blank.rb, line 37
37:   def blank?
38:     strip.empty?
39:   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 115
115:   def camelize(first_letter_in_uppercase = :upper)
116:     s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
117:     s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
118:     s
119:   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 129
129:   def classify
130:     sub(/.*\./, '').singularize.camelize
131:   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 140
140:   def constantize
141:     raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
142:     Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
143:   end

Replaces underscores with dashes in the string.

Example

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

[Source]

     # File lib/sequel/extensions/inflector.rb, line 149
149:   def dasherize
150:     gsub(/_/, '-')
151:   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 158
158:   def demodulize
159:     gsub(/^.*::/, '')
160:   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 169
169:   def foreign_key(use_underscore = true)
170:     "#{demodulize.underscore}#{'_' if use_underscore}id"
171:   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 179
179:   def humanize
180:     gsub(/_id$/, "").gsub(/_/, " ").capitalize
181:   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/extensions/core_extensions.rb, line 189
189:   def lit(*args)
190:     args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
191:   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 192
192:   def pluralize
193:     result = dup
194:     Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
195:     result
196:   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 207
207:   def singularize
208:     result = dup
209:     Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
210:     result
211:   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 219
219:   def tableize
220:     underscore.pluralize
221:   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 231
231:   def titleize
232:     underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
233:   end

Converts a string into a Date object.

[Source]

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

Converts a string into a DateTime object.

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 20
20:   def to_datetime
21:     begin
22:       DateTime.parse(self, Sequel.convert_two_digit_years)
23:     rescue => e
24:       raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
25:     end
26:   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/extensions/core_extensions.rb, line 195
195:   def to_sequel_blob
196:     ::Sequel::SQL::Blob.new(self)
197:   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 30
30:   def to_sequel_time
31:     begin
32:       if Sequel.datetime_class == DateTime
33:         DateTime.parse(self, Sequel.convert_two_digit_years)
34:       else
35:         Sequel.datetime_class.parse(self)
36:       end
37:     rescue => e
38:       raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
39:     end
40:   end

Converts a string into a Time object.

[Source]

    # File lib/sequel/extensions/string_date_time.rb, line 43
43:   def to_time
44:     begin
45:       Time.parse(self)
46:     rescue => e
47:       raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
48:     end
49:   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 242
242:   def underscore
243:     gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
244:       gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
245:   end

[Validate]