Class: String

Inherits:
Object show all
Includes:
Sequel::SQL::AliasMethods, Sequel::SQL::CastMethods
Defined in:
lib/sequel_model/inflector.rb,
lib/sequel_core/core_ext.rb,
lib/sequel_core/core_sql.rb

Overview

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.

Direct Known Subclasses

Sequel::LiteralString, Sequel::SQL::Blob

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:



135
136
137
138
 
# File 'lib/sequel_model/inflector.rb', line 135

def self.inflections
  yield Inflections if block_given?
  Inflections
end

Instance Method Details

#blank? ⇒ Boolean

Strings are blank if they are empty or include only whitespace

Returns:

  • (Boolean) 


166
167
168
 
# File 'lib/sequel_core/core_ext.rb', line 166

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"



150
151
152
153
154
 
# File 'lib/sequel_model/inflector.rb', line 150

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"



164
165
166
 
# File 'lib/sequel_model/inflector.rb', line 164

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) 


175
176
177
178
 
# File 'lib/sequel_model/inflector.rb', line 175

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"



184
185
186
 
# File 'lib/sequel_model/inflector.rb', line 184

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"



193
194
195
 
# File 'lib/sequel_model/inflector.rb', line 193

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"



204
205
206
 
# File 'lib/sequel_model/inflector.rb', line 204

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"



214
215
216
 
# File 'lib/sequel_model/inflector.rb', line 214

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

#lit(*args) ⇒ Object Also known as: expr

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"



137
138
139
 
# File 'lib/sequel_core/core_sql.rb', line 137

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"



227
228
229
230
231
 
# File 'lib/sequel_model/inflector.rb', line 227

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"



242
243
244
245
246
 
# File 'lib/sequel_model/inflector.rb', line 242

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

#split_sql ⇒ Object

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



144
145
146
 
# File 'lib/sequel_core/core_sql.rb', line 144

def split_sql
  to_sql.split(';').map {|s| s.strip}
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"



254
255
256
 
# File 'lib/sequel_model/inflector.rb', line 254

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"



266
267
268
 
# File 'lib/sequel_model/inflector.rb', line 266

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

#to_date ⇒ Object

Converts a string into a Date object.



171
172
173
174
175
176
177
 
# File 'lib/sequel_core/core_ext.rb', line 171

def to_date
  begin
    Date.parse(self, Sequel.convert_two_digit_years)
  rescue => e
    raise Sequel::Error::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
  end
end

#to_datetime ⇒ Object

Converts a string into a DateTime object.



180
181
182
183
184
185
186
 
# File 'lib/sequel_core/core_ext.rb', line 180

def to_datetime
  begin
    DateTime.parse(self, Sequel.convert_two_digit_years)
  rescue => e
    raise Sequel::Error::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
  end
end

#to_sequel_blob ⇒ Object Also known as: to_blob

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



156
157
158
 
# File 'lib/sequel_core/core_sql.rb', line 156

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



190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/sequel_core/core_ext.rb', line 190

def to_sequel_time
  begin
    if Sequel.datetime_class == DateTime
      DateTime.parse(self, Sequel.convert_two_digit_years)
    else
      Sequel.datetime_class.parse(self)
    end
  rescue => e
    raise Sequel::Error::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
  end
end

#to_sql ⇒ Object

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



150
151
152
 
# File 'lib/sequel_core/core_sql.rb', line 150

def to_sql
  split("\n").to_sql
end

#to_time ⇒ Object

Converts a string into a Time object.



203
204
205
206
207
208
209
 
# File 'lib/sequel_core/core_ext.rb', line 203

def to_time
  begin
    Time.parse(self)
  rescue => e
    raise Sequel::Error::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
  end
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



277
278
279
280
 
# File 'lib/sequel_model/inflector.rb', line 277

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