class String

def acts_like_string?
  true
end

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

def at(position)
  mb_chars[position, 1].to_s
end

def at(position)
  self[position]
end

def blank?
  # 1.8 does not takes [:space:] properly
  if encoding_aware?
    self !~ /[^[:space:]]/
  else
    self !~ NON_WHITESPACE_REGEXP
  end
end

def camelize(first_letter = :upper)
  case first_letter
    when :upper then ActiveSupport::Inflector.camelize(self, true)
    when :lower then ActiveSupport::Inflector.camelize(self, false)
  end
end

def classify
  ActiveSupport::Inflector.classify(self)
end

def constantize
  ActiveSupport::Inflector.constantize(self)
end

def dasherize
  ActiveSupport::Inflector.dasherize(self)
end

def deconstantize
  ActiveSupport::Inflector.deconstantize(self)
end

def demodulize
  ActiveSupport::Inflector.demodulize(self)
end

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

def encoding_aware?
  true
end

def encoding_aware?
  false
end

def exclude?(string)
  !include?(string)
end

def first(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    mb_chars[0...limit].to_s
  end
end

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)
  ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
end

def from(position)
  mb_chars[position..-1].to_s
end

def from(position)
  self[position..-1]
end

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

def humanize
  ActiveSupport::Inflector.humanize(self)
end

def inquiry
  ActiveSupport::StringInquirer.new(self)
end

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 is_utf8?
  ActiveSupport::Multibyte::Chars.consumes?(self)
end

def last(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    mb_chars[(-limit)..-1].to_s
  end
end

def last(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    from(-limit)
  end
end

def mb_chars
  if ActiveSupport::Multibyte.proxy_class.consumes?(self)
    ActiveSupport::Multibyte.proxy_class.new(self)
  else
    self
  end
end

def mb_chars
  if ActiveSupport::Multibyte.proxy_class.wants?(self)
    ActiveSupport::Multibyte.proxy_class.new(self)
  else
    self
  end
end

def ord
  self[0]
end unless method_defined?(:ord)

def parameterize(sep = '-')
  ActiveSupport::Inflector.parameterize(self, sep)
end

def pluralize(count = nil)
  if count == 1
    self
  else
    ActiveSupport::Inflector.pluralize(self)
  end
end

def safe_constantize
  ActiveSupport::Inflector.safe_constantize(self)
end

def singularize
  ActiveSupport::Inflector.singularize(self)
end

def squish
  dup.squish!
end

def squish!
  strip!
  gsub!(/\s+/, ' ')
  self
end

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

def tableize
  ActiveSupport::Inflector.tableize(self)
end

def titleize
  ActiveSupport::Inflector.titleize(self)
end

def to(position)
  mb_chars[0..position].to_s
end

def to(position)
  self[0..position]
end

def to_date
  return nil if self.blank?
  ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
end

def to_datetime
  return nil if self.blank?
  d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :sec_fraction).map { |arg| arg || 0 }
  d[5] += d.pop
  ::DateTime.civil(*d)
end

def to_time(form = :utc)
  return nil if self.blank?
  d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset).map { |arg| arg || 0 }
  d[6] *= 1000000
  ::Time.send("#{form}_time", *d[0..6]) - d[7]
end

def truncate(length, options = {})
  text = self.dup
  options[:omission] ||= "..."
  length_with_room_for_omission = length - options[:omission].mb_chars.length
  chars = text.mb_chars
  stop = options[:separator] ?
    (chars.rindex(options[:separator].mb_chars, length_with_room_for_omission) || length_with_room_for_omission) : length_with_room_for_omission
  (chars.length > length ? chars[0...stop] + options[:omission] : text).to_s
end

def underscore
  ActiveSupport::Inflector.underscore(self)
end