class String

  unless method_defined?(:camelize)
    def camelize(first_letter_in_uppercase = true)
      if first_letter_in_uppercase != :lower
        to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
      else
        to_s[0].chr.downcase + camelize(self)[1..-1]
      end
    end
  end

  unless method_defined?(:camelize!)
    def camelize!(first_letter_in_uppercase = true)
      replace(camelize(first_letter_in_uppercase))
    end
  end

  unless method_defined?(:ends_with?)
    def ends_with?(suffix)
      suffix = suffix.to_s
      self[-suffix.length, suffix.length] == suffix
    end
  end

  unless method_defined?(:humanize)
    def humanize(options = {})
      underscore.
      gsub(/_id$/, "").
      tr('_', ' ').
      gsub(/([a-z\d]*)/i) { |match| match.downcase }.
      gsub(/^\w/) { |match| match.upcase } if options.fetch(:capitalize, true)
    end
  end

  unless method_defined?(:humanize!)
    def humanize!(options = {})
      replace(humanize)
    end
  end

  unless method_defined?(:titleize)
    def titleize
      underscore.
      humanize.
      gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
    end
  end

  unless method_defined?(:titleize!)
    def titleize!
      replace(titleize)
    end
  end

  unless method_defined?(:starts_with?)
    def starts_with?(prefix)
      prefix = prefix.to_s
      self[0, prefix.length] == prefix
    end
  end

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

  unless method_defined?(:underscore!)
    def underscore!
      replace(underscore)
    end
  end

  def domain(options={})
    url = dup
    url =~ (/^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)/) ? $1 : url
  end

  def downcase?
    downcase == self
  end

  def ellipsize(options={})
     length    = options[:length]    || 30
     separator = options[:separator] || '...'
     return self if size <= length
     offset    = options[:offset]    || 4
     self[0,offset] + separator + self[-offset,offset]
  end

  def gnix(string)
    gsub(string, "")
  end

  def gnix!(string)
    gsub!(string, "")
  end

  def mixedcase?
    !upcase? && !downcase?
  end

  def nix(string)
    sub(string, "")
  end

  def nix!(string)
    sub!(string, "")
  end

  def pollute(delimiter="^--^--^")
    split('').map{ |letter| "#{letter}#{delimiter}" }.join
  end

  def slugify
    gsub(/[^\x00-\x7F]+/, '').    # Remove anything non-ASCII entirely (e.g. diacritics).
    gsub(/[^\w_ \-]+/i,   '').    # Remove unwanted chars.
    gsub(/[ \-]+/i,      '-').    # No more than one of the separator in a row.
    gsub(/^\-|\-$/i,      '').    # Remove leading/trailing separator.
    downcase
  end

  def slugify!
    replace(slugify)
  end

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

  def squish!
    replace(squish)
  end

  def strip_tags
    gsub(/<\/?[^>]*>/, "")
  end

  def strip_tags!
    replace(strip_tags)
  end

  def strip_whitespace
    gnix("\t").split(" ").remove_blanks.join(" ")
  end

  def strip_whitespace!
    replace(strip_whitespace)
  end

  def truncate_preserving_words(options={})
    separator = options[:separator] || '...'
    max_words = options[:max_words] || nil
    if max_words
      words = split
      return self if words.size < max_words
      words = words[0..(max_words-1)]
      words << separator
      words.join(" ")
    else
      max_chars = options[:max_chars] || 30
      return self if size < max_chars
      out = self[0..(max_chars-1)].split(" ")
      out.pop
      out << separator
      out.join(" ")
    end
  end

  def unpollute(delimiter="^--^--^")
    gsub(delimiter, "")
  end

  def upcase?
    upcase == self
  end

end