class String

  unless method_defined?("camelize")
    def camelize(first_letter_in_uppercase = true)
      if first_letter_in_uppercase != :lower
        self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
      else
        self.to_s[0].chr.downcase + camelize(self)[1..-1]
      end
    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 = {})
      self.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?("titleize")
    def titleize
      self.underscore.
      humanize.
      gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
    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
      self.gsub(/::/, '/').
      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
      gsub(/([a-z\d])([A-Z])/,'\1_\2').
      tr("-", "_").
      downcase
    end
  end

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

  def downcase?
    self.downcase == self
  end

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

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

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

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

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

  def slugify
    self.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 strip_tags
    self.gsub(/<\/?[^>]*>/, "")
  end

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

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

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

  def upcase?
    self.upcase == self
  end

end