class String

def acts_like_string?

Enable more predictable duck-typing on String-like classes. See Object#acts_like?. 
def acts_like_string?
  true
end

def as_json(options = nil) #:nodoc:

:nodoc: 
def as_json(options = nil) #:nodoc:
  self
end

def at(position)

str.at("ol") #=> nil
str.at("lo") #=> "lo"
str.at(/ol/) #=> nil
str.at(/lo/) #=> "lo"
str = "hello"

the string. In both cases, nil is returned if there is no match.
If a String is given, that given string is returned if it occurs in
If a Regexp is given, the matching portion of the string is returned.

str.at(5..-1) #=> ""
str.at(5) #=> nil
str.at(-2..-1) #=> "lo"
str.at(-2) #=> "l"
str.at(1..3) #=> "ell"
str.at(0) #=> "h"
str = "hello"

the beginning of the range is greater than the end of the string.
if the initial offset falls outside the string. Returns an empty string if
offset is negative, it is counted from the end of the string. Returns nil
characters at offsets given by the range is returned. In both cases, if an
position 1, and so on. If a range is supplied, a substring containing
position. The first character of the string is at position 0, the next at
If you pass a single Fixnum, returns a substring of one character at that 
def at(position)
  self[position]
end

def blank?

' something here '.blank? # => false
'　'.blank? # => true
' '.blank? # => true
''.blank? # => true

A string is blank if it's empty or contains whitespaces only: 
def blank?
  self !~ /[^[:space:]]/
end

def camelize(first_letter = :upper)

'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
'active_record/errors'.camelize # => "ActiveRecord::Errors"
'active_record'.camelize(:lower) # => "activeRecord"
'active_record'.camelize # => "ActiveRecord"

+camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.

is set to :lower then camelize produces lowerCamelCase.
By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize 
def camelize(first_letter = :upper)
  case first_letter
  when :upper
    ActiveSupport::Inflector.camelize(self, true)
  when :lower
    ActiveSupport::Inflector.camelize(self, false)
  end
end

def classify

'business'.classify # => "Busines"

Singular names are not handled correctly.

'posts'.classify # => "Post"
'egg_and_hams'.classify # => "EggAndHam"

follow +classify+ with +constantize+.)
Note that this returns a string and not a class. (To convert to an actual class
Create a class name from a plural table name like Rails does for table names to models. 
def classify
  ActiveSupport::Inflector.classify(self)
end

def constantize

'blargle'.constantize # => NameError: wrong constant name blargle
'Class'.constantize # => Class
'Module'.constantize # => Module

or is not initialized. See ActiveSupport::Inflector.constantize
in the string. It raises a NameError when the name is not in CamelCase
+constantize+ tries to find a declared constant with the name specified 
def constantize
  ActiveSupport::Inflector.constantize(self)
end

def dasherize

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

Replaces underscores with dashes in the string. 
def dasherize
  ActiveSupport::Inflector.dasherize(self)
end

def deconstantize

See also +demodulize+.

''.deconstantize # => ""
'::String'.deconstantize # => ""
'String'.deconstantize # => ""
'::Net::HTTP'.deconstantize # => "::Net"
'Net::HTTP'.deconstantize # => "Net"

Removes the rightmost segment from the constant expression in the string. 
def deconstantize
  ActiveSupport::Inflector.deconstantize(self)
end

def demodulize

See also +deconstantize+.

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

Removes the module part from the constant expression in the string. 
def demodulize
  ActiveSupport::Inflector.demodulize(self)
end

def encode_json(encoder) #:nodoc:

:nodoc: 
def encode_json(encoder) #:nodoc:
  encoder.escape(self)
end

def encoding_aware? 

def encoding_aware?
  ActiveSupport::Deprecation.warn 'String#encoding_aware? is deprecated'
  true
end

def exclude?(string)

"hello".exclude? ?h #=> false
"hello".exclude? "ol" #=> true
"hello".exclude? "lo" #=> false

does not include the other string.
The inverse of String#include?. Returns true if the string 
def exclude?(string)
  !include?(string)
end

def first(limit = 1)

str.first(6) #=> "hello"
str.first(0) #=> ""
str.first(2) #=> "he"
str.first(1) #=> "h"
str.first #=> "h"
str = "hello"

given limit is greater than or equal to the string length, returns self.
from the beginning of the string until it reaches the limit value. If the
Returns the first character. If a limit is supplied, returns a substring 
def first(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    to(limit - 1)
  end
end

def foreign_key(separate_class_name_and_id_with_underscore = true)

'Admin::Post'.foreign_key # => "post_id"
'Message'.foreign_key(false) # => "messageid"
'Message'.foreign_key # => "message_id"

the method should put '_' between the name and 'id'.
+separate_class_name_and_id_with_underscore+ sets whether
Creates a foreign key name from a class name. 
def foreign_key(separate_class_name_and_id_with_underscore = true)
  ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
end

def from(position)

str.from(1).to(-2) #=> "ell"
str.from(0).to(-1) #=> "hello"
str = "hello"

You can mix it with +to+ method and do fun things like:

str.from(-2) #=> "lo"
str.from(3) #=> "lo"
str.from(0) #=> "hello"
str = "hello"

If the position is negative, it is counted from the end of the string.
Returns a substring from the given position to the end of the string. 
def from(position)
  self[position..-1]
end

def html_safe 

def html_safe
  ActiveSupport::SafeBuffer.new(self)
end

def humanize

'author_id'.humanize # => "Author"
'employee_salary'.humanize # => "Employee salary"

Like +titleize+, this is meant for creating pretty output.
Capitalizes the first word, turns underscores into spaces, and strips '_id'. 
def humanize
  ActiveSupport::Inflector.humanize(self)
end

def in_time_zone(zone = ::Time.zone)

is set, otherwise converts String to a Time via String#to_time
Converts String to a TimeWithZone in the current zone if Time.zone or Time.zone_default 
def in_time_zone(zone = ::Time.zone)
  if zone
    ::Time.find_zone!(zone).parse(self)
  else
    to_time
  end
end

def indent(amount, indent_string=nil, indent_empty_lines=false)


"foo\n\nbar".indent(2, nil, true) # => " foo\n \n bar"
"foo\n\nbar".indent(2) # => " foo\n\n bar"

empty lines should be indented. Default is false.
The third argument, +indent_empty_lines+, is a flag that says whether

While +indent_string+ is typically one space or tab, it may be any string.

"foo".indent(2, "\t") # => "\t\tfoo"
"foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar"
" foo".indent(2) # => " foo"

none.
peeking at the first indented line, and fallback to a space if there is
use. The default is +nil+, which tells the method to make a guess by
The second argument, +indent_string+, specifies which indent string to

end
some_code
def some_method
# =>
EOS
end
some_code
def some_method
<
Indents the lines in the receiver: 
def indent(amount, indent_string=nil, indent_empty_lines=false)
  dup.tap {|_| _.indent!(amount, indent_string, indent_empty_lines)}
end

def indent!(amount, indent_string=nil, indent_empty_lines=false)

Returns the indented string, or +nil+ if there was nothing to indent.

Same as +indent+, except it indents the receiver in-place. 
def indent!(amount, indent_string=nil, indent_empty_lines=false)
  indent_string = indent_string || self[/^[ \t]/] || ' '
  re = indent_empty_lines ? /^/ : /^(?!$)/
  gsub!(re, indent_string * amount)
end

def inquiry

env.development? # => false
env.production? # => true
env = 'production'.inquiry

which gives you a prettier way to test for equality.
Wraps the current string in the ActiveSupport::StringInquirer class, 
def inquiry
  ActiveSupport::StringInquirer.new(self)
end

def is_utf8? 

def is_utf8?
  case encoding
  when Encoding::UTF_8
    valid_encoding?
  when Encoding::ASCII_8BIT, Encoding::US_ASCII
    dup.force_encoding(Encoding::UTF_8).valid_encoding?
  else
    false
  end
end

def last(limit = 1)

str.last(6) #=> "hello"
str.last(0) #=> ""
str.last(2) #=> "lo"
str.last(1) #=> "o"
str.last #=> "o"
str = "hello"

the given limit is greater than or equal to the string length, returns self.
from the end of the string until it reaches the limit value (counting backwards). If
Returns the last character of the string. If a limit is supplied, returns a substring 
def last(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    from(-limit)
  end
end

def mb_chars

information about how to change the default Multibyte behavior see ActiveSupport::Multibyte.
For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For

object. Interoperability problems can be resolved easily with a +to_s+ call.
String and Char work like expected. The bang! methods change the internal string representation in the Chars
The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between

== Interoperability and configuration

name.mb_chars.reverse.length # => 12

method chaining on the result of any of these methods.
All the methods on the Chars proxy which normally return a string will return a Chars object. This allows

== Method chaining

name.mb_chars.length # => 12
name.mb_chars.reverse.to_s # => "rellüM sualC"

name.length # => 13
name.reverse # => "rell??M sualC"
name = 'Claus Müller'

class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
It creates and returns an instance of the ActiveSupport::Multibyte::Chars class which

+mb_chars+ is a multibyte safe proxy for string methods.

== Multibyte proxy 
def mb_chars
  ActiveSupport::Multibyte.proxy_class.new(self)
end

def parameterize(sep = '-')

# => Donald E. Knuth
<%= link_to(@person.name, person_path) %>

# => #
@person = Person.find(1)

end
end
"#{id}-#{name.parameterize}"
def to_param
class Person

Replaces special characters in a string so that it may be used as part of a 'pretty' URL. 
def parameterize(sep = '-')
  ActiveSupport::Inflector.parameterize(self, sep)
end

def pluralize(count = nil, locale = :en)

'ley'.pluralize(1, :es) # => "ley"
'ley'.pluralize(:es) # => "leyes"
'apple'.pluralize(2) # => "apples"
'apple'.pluralize(1) # => "apple"
'CamelOctopus'.pluralize # => "CamelOctopi"
'the blue mailman'.pluralize # => "the blue mailmen"
'words'.pluralize # => "words"
'sheep'.pluralize # => "sheep"
'octopus'.pluralize # => "octopi"
'post'.pluralize # => "posts"

You must define your own inflection rules for languages other than English.
By default, this parameter is set to :en.
the word will be pluralized as a word of that language.
If the optional parameter +locale+ is specified,

For any other value of +count+ the plural will be returned.
the singular form will be returned if count == 1.
If the optional parameter +count+ is specified,

Returns the plural form of the word in the string. 
def pluralize(count = nil, locale = :en)
  locale = count if count.is_a?(Symbol)
  if count == 1
    self
  else
    ActiveSupport::Inflector.pluralize(self, locale)
  end
end

def safe_constantize

'blargle'.safe_constantize # => nil
'Class'.safe_constantize # => Class
'Module'.safe_constantize # => Module

or is not initialized. See ActiveSupport::Inflector.safe_constantize
in the string. It returns nil when the name is not in CamelCase
+safe_constantize+ tries to find a declared constant with the name specified 
def safe_constantize
  ActiveSupport::Inflector.safe_constantize(self)
end

def singularize(locale = :en)

'leyes'.singularize(:es) # => "ley"
'CamelOctopi'.singularize # => "CamelOctopus"
'the blue mailmen'.singularize # => "the blue mailman"
'word'.singularize # => "word"
'sheep'.singularize # => "sheep"
'octopi'.singularize # => "octopus"
'posts'.singularize # => "post"

You must define your own inflection rules for languages other than English.
By default, this parameter is set to :en.
the word will be singularized as a word of that language.
If the optional parameter +locale+ is specified,

The reverse of +pluralize+, returns the singular form of a word in a string. 
def singularize(locale = :en)
  ActiveSupport::Inflector.singularize(self, locale)
end

def squish

" foo bar \n \t boo".squish # => "foo bar boo"
string }.squish # => "Multi-line string"
%{ Multi-line

Note that it handles both ASCII and Unicode whitespace like mongolian vowel separator (U+180E).

groups into one space each.
the string, and then changing remaining consecutive whitespace
Returns the string, first removing all whitespace on both ends of 
def squish
  dup.squish!
end

def squish!

Performs a destructive squish. See String#squish. 
def squish!
  gsub!(/\A[[:space:]]+/, '')
  gsub!(/[[:space:]]+\z/, '')
  gsub!(/[[:space:]]+/, ' ')
  self
end

def strip_heredoc

that amount of leading whitespace.
Technically, it looks for the least indented line in the whole string, and removes

the user would see the usage message aligned against the left margin.

end
USAGE
...
-h This message
Supported options are:

This command does such and such.
puts <<-USAGE.strip_heredoc
if options[:usage]

For example in

Strips indentation in heredocs. 
def strip_heredoc
  indent = scan(/^[ \t]*(?=\S)/).min.try(:size) || 0
  gsub(/^[ \t]{#{indent}}/, '')
end

def tableize

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

uses the +pluralize+ method on the last word in the string.
Creates the name of a table like Rails does for models to table names. This method 
def tableize
  ActiveSupport::Inflector.tableize(self)
end

def titleize

'x-men: the last stand'.titleize # => "X Men: The Last Stand"
'man from the boondocks'.titleize # => "Man From The Boondocks"

+titleize+ is also aliased as +titlecase+.

used in the Rails internals.
a nicer looking title. +titleize+ is meant for creating pretty output. It is not
Capitalizes all the words and replaces some characters in the string to create 
def titleize
  ActiveSupport::Inflector.titleize(self)
end

def to(position)

str.from(1).to(-2) #=> "ell"
str.from(0).to(-1) #=> "hello"
str = "hello"

You can mix it with +from+ method and do fun things like:

str.to(-2) #=> "hell"
str.to(3) #=> "hell"
str.to(0) #=> "h"
str = "hello"

If the position is negative, it is counted from the end of the string.
Returns a substring from the beginning of the string to the given position. 
def to(position)
  self[0..position]
end

def to_date

"12/13/2012".to_date #=> ArgumentError: invalid date
"2012-12-13".to_date #=> Thu, 13 Dec 2012
"01/01/2012".to_date #=> Sun, 01 Jan 2012
"1-1-2012".to_date #=> Sun, 01 Jan 2012

Converts a string to a Date value. 
def to_date
  ::Date.parse(self, false) unless blank?
end

def to_datetime

"12/13/2012".to_datetime #=> ArgumentError: invalid date
"2012-12-13 12:50".to_datetime #=> Thu, 13 Dec 2012 12:50:00 +0000
"01/01/2012 23:59:59".to_datetime #=> Sun, 01 Jan 2012 23:59:59 +0000
"1-1-2012".to_datetime #=> Sun, 01 Jan 2012 00:00:00 +0000

Converts a string to a DateTime value. 
def to_datetime
  ::DateTime.parse(self, false) unless blank?
end

def to_time(form = :local)

"2012-12-13T06:12".to_time(:utc) # => 2012-12-13 05:12:00 UTC
"2012-12-13T06:12".to_time # => 2012-12-13 06:12:00 +0100
"2012-12-13 06:12".to_time # => 2012-12-13 06:12:00 +0100
"06:12".to_time # => 2012-12-13 06:12:00 +0100
"13-12-2012".to_time # => 2012-12-13 00:00:00 +0100

the time part is missing then it is assumed to be 00:00:00.
If the date part is missing then the current date is used and if
If +form+ is :local, then the time is in the system timezone.
The time is parsed using Time.parse method.

The +form+ can be either :utc or :local (default :local).
Converts a string to a Time value. 
def to_time(form = :local)
  parts = Date._parse(self, false)
  return if parts.empty?
  now = Time.now
  time = Time.new(
    parts.fetch(:year, now.year),
    parts.fetch(:mon, now.month),
    parts.fetch(:mday, now.day),
    parts.fetch(:hour, 0),
    parts.fetch(:min, 0),
    parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
    parts.fetch(:offset, form == :utc ? 0 : nil)
  )
  form == :utc ? time.utc : time.getlocal
end

def truncate(truncate_at, options = {})

# => "And they f... (continued)"
'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')

for a total length not exceeding length:
The last characters will be replaced with the :omission string (defaults to "...")

# => "Once upon a time in a..."
'Once upon a time in a world far far away'.truncate(27, separator: /\s/)

# => "Once upon a time in a..."
'Once upon a time in a world far far away'.truncate(27, separator: ' ')

Pass a string or regexp :separator to truncate +text+ at a natural break:

# => "Once upon a time in a wo..."
'Once upon a time in a world far far away'.truncate(27)

Truncates a given +text+ after a given length if +text+ is longer than length: 
def truncate(truncate_at, options = {})
  return dup unless length > truncate_at
  options[:omission] ||= '...'
  length_with_room_for_omission = truncate_at - options[:omission].length
  stop = \
    if options[:separator]
      rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
    else
      length_with_room_for_omission
    end
  "#{self[0...stop]}#{options[:omission]}"
end

def underscore

'ActiveModel::Errors'.underscore # => "active_model/errors"
'ActiveModel'.underscore # => "active_model"

+underscore+ will also change '::' to '/' to convert namespaces to paths.

The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string. 
def underscore
  ActiveSupport::Inflector.underscore(self)
end