class String

def acts_like_string?
  true
end

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

def at(position)
  self[position]
end

def blank?
  # The regexp that matches blank strings is expensive. For the case of empty
  # strings we can speed up this method (~3.5x) with an empty? call. The
  # penalty for the rest of strings is marginal.
  empty? || BLANK_RE === self
end

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
  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 exclude?(string)
  !include?(string)
end

def first(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self.dup
  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)
  self[position..-1]
end

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

def humanize(options = {})
  ActiveSupport::Inflector.humanize(self, options)
end

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)
  dup.tap {|_| _.indent!(amount, indent_string, indent_empty_lines)}
end

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
  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 last(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self.dup
  else
    from(-limit)
  end
end

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

def parameterize(sep = :unused, separator: '-', preserve_case: false)
  unless sep == :unused
    ActiveSupport::Deprecation.warn("Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '#{sep}'` instead.")
    separator = sep
  end
  ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case)
end

def pluralize(count = nil, locale = :en)
  locale = count if count.is_a?(Symbol)
  if count == 1
    self.dup
  else
    ActiveSupport::Inflector.pluralize(self, locale)
  end
end

def remove(*patterns)
  dup.remove!(*patterns)
end

def remove!(*patterns)
  patterns.each do |pattern|
    gsub! pattern, ""
  end
  self
end

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

def singularize(locale = :en)
  ActiveSupport::Inflector.singularize(self, locale)
end

def squish
  dup.squish!
end

def squish!
  gsub!(/[[:space:]]+/, ' ')
  strip!
  self
end

def strip_heredoc
  gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, ''.freeze)
end

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

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

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

def to_date
  ::Date.parse(self, false) unless blank?
end

def to_datetime
  ::DateTime.parse(self, false) unless blank?
end

def to_time(form = :local)
  parts = Date._parse(self, false)
  used_keys = %i(year mon mday hour min sec sec_fraction offset)
  return if (parts.keys & used_keys).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.to_time
end

def truncate(truncate_at, options = {})
  return dup unless length > truncate_at
  omission = options[:omission] || '...'
  length_with_room_for_omission = truncate_at - 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]}#{omission}"
end

def truncate_words(words_count, options = {})
  sep = options[:separator] || /\s+/
  sep = Regexp.escape(sep.to_s) unless Regexp === sep
  if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
    $1 + (options[:omission] || '...')
  else
    dup
  end
end

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

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