Class: String

Class | String
In: | lib/sequel_core/core_ext.rb lib/sequel_core/core_sql.rb lib/sequel_model/inflector.rb
Parent: | Object

Add inflection 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.

### Methods

blank? camelcase camelize classify constantize dasherize demodulize expr foreign_key humanize inflections lit pluralize singularize split_sql tableize titlecase titleize to_blob to_date to_datetime to_sequel_time to_sql 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_model/inflector.rb, line 135
    135:   def self.inflections
    136:     yield Inflections if block_given?
    137:     Inflections
    138:   end

### Public Instance methods

blank?()

Strings are blank if they are empty or include only whitespace

[Source]

         # File lib/sequel_core/core_ext.rb, line 166
    166:   def blank?
    167:     strip.empty?
    168:   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_model/inflector.rb, line 150
    150:   def camelize(first_letter_in_uppercase = :upper)
    151:     s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
    152:     s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
    153:     s
    154:   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_model/inflector.rb, line 164
    164:   def classify
    165:     sub(/.*\./, '').singularize.camelize
    166:   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_model/inflector.rb, line 175
    175:   def constantize
    176:     raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
    177:     Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
    178:   end

dasherize()

Replaces underscores with dashes in the string.

Example

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

[Source]

         # File lib/sequel_model/inflector.rb, line 184
    184:   def dasherize
    185:     gsub(/_/, '-')
    186:   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_model/inflector.rb, line 193
    193:   def demodulize
    194:     gsub(/^.*::/, '')
    195:   end

expr()

Alias for lit

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_model/inflector.rb, line 204
    204:   def foreign_key(use_underscore = true)
    205:     "#{demodulize.underscore}#{'_' if use_underscore}id"
    206:   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_model/inflector.rb, line 214
    214:   def humanize
    215:     gsub(/_id$/, "").gsub(/_/, " ").capitalize
    216:   end

lit()

Converts a string into an 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)"

[Source]

         # File lib/sequel_core/core_sql.rb, line 133
    133:   def lit
    134:     Sequel::LiteralString.new(self)
    135:   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_model/inflector.rb, line 227
    227:   def pluralize
    228:     result = dup
    229:     Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
    230:     result
    231:   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_model/inflector.rb, line 242
    242:   def singularize
    243:     result = dup
    244:     Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
    245:     result
    246:   end

split_sql()

Splits a string into separate SQL statements, removing comments and excessive white-space.

[Source]

         # File lib/sequel_core/core_sql.rb, line 140
    140:   def split_sql
    141:     to_sql.split(';').map {|s| s.strip}
    142:   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_model/inflector.rb, line 254
    254:   def tableize
    255:     underscore.pluralize
    256:   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_model/inflector.rb, line 266
    266:   def titleize
    267:     underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
    268:   end

to_blob()

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

[Source]

         # File lib/sequel_core/core_sql.rb, line 152
    152:   def to_blob
    153:     ::Sequel::SQL::Blob.new self
    154:   end

to_date()

Converts a string into a Date object.

[Source]

         # File lib/sequel_core/core_ext.rb, line 171
    171:   def to_date
    172:     begin
    173:       Date.parse(self, Sequel.convert_two_digit_years)
    174:     rescue => e
    175:       raise Sequel::Error::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
    176:     end
    177:   end

to_datetime()

Converts a string into a DateTime object.

[Source]

         # File lib/sequel_core/core_ext.rb, line 180
    180:   def to_datetime
    181:     begin
    182:       DateTime.parse(self, Sequel.convert_two_digit_years)
    183:     rescue => e
    184:       raise Sequel::Error::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
    185:     end
    186:   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_core/core_ext.rb, line 190
    190:   def to_sequel_time
    191:     begin
    192:       if Sequel.datetime_class == DateTime
    193:         DateTime.parse(self, Sequel.convert_two_digit_years)
    194:       else
    195:         Sequel.datetime_class.parse(self)
    196:       end
    197:     rescue => e
    198:       raise Sequel::Error::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
    199:     end
    200:   end

to_sql()

Converts a string into an SQL string by removing comments. See also Array#to_sql.

[Source]

         # File lib/sequel_core/core_sql.rb, line 146
    146:   def to_sql
    147:     split("\n").to_sql
    148:   end

to_time()

Converts a string into a Time object.

[Source]

         # File lib/sequel_core/core_ext.rb, line 203
    203:   def to_time
    204:     begin
    205:       Time.parse(self)
    206:     rescue => e
    207:       raise Sequel::Error::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
    208:     end
    209:   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_model/inflector.rb, line 277
    277:   def underscore
    278:     gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    279:       gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
    280:   end

[Validate]