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

blank? camelcase camelize classify constantize dasherize demodulize foreign_key humanize inflections lit pluralize singularize tableize titlecase titleize to_date to_datetime to_sequel_blob to_sequel_time to_time underscore

### Included Modules

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

### Classes and Modules

Module String::Inflections

### Public Class methods

inflections() {|Inflections if block_given?| ...}

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

blank?()

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

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"

[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

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"

[Source]

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

[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

dasherize()

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

demodulize()

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

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"

[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

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"

[Source]

         # File lib/sequel/extensions/inflector.rb, line 179
    179:   def humanize
    180:     gsub(/_id$/, "").gsub(/_/, " ").capitalize
    181:   end

lit(*args)

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

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"

[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

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"

[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

tableize()

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

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

to_date()

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

to_datetime()

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

to_sequel_blob()

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

to_sequel_time()

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

to_time()

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

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

[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]