module Stringex::StringExtensions::PublicInstanceMethods

def collapse(character = " ")
  sub(/^#{character}*/, "").sub(/#{character}*$/, "").squeeze(character)
end

def convert_accented_html_entities
  stringex_convert do
    cleanup_accented_html_entities!
  end
end

def convert_miscellaneous_characters(options = {})
  stringex_convert(options) do
    normalize_currency!
    translate! :ellipses, :currencies, :abbreviations, :characters, :apostrophes
    cleanup_characters!
  end
end

def convert_miscellaneous_html_entities
  stringex_convert do
    translate! :html_entities
    cleanup_html_entities!
  end
end

def convert_smart_punctuation
  stringex_convert do
    cleanup_smart_punctuation!
  end
end

def convert_unreadable_control_characters
  stringex_convert do
    translate! :unreadable_control_characters
  end
end

def convert_vulgar_fractions
  stringex_convert do
    translate! :vulgar_fractions
  end
end

def limit(limit = nil, truncate_words = true, whitespace_replacement_token = "-")
  if limit.nil?
    self
  else
    truncate_words == false ? self.whole_word_limit(limit, whitespace_replacement_token) : self[0...limit]
  end
end

def remove_formatting(options = {})
  strip_html_tags.
    convert_smart_punctuation.
    convert_accented_html_entities.
    convert_vulgar_fractions.
    convert_unreadable_control_characters.
    convert_miscellaneous_html_entities.
    convert_miscellaneous_characters(options).
    to_ascii.
    # NOTE: String#to_ascii may convert some Unicode characters to ascii we'd already transliterated
    # so we need to do it again just to be safe
    convert_miscellaneous_characters(options).
    collapse
end

def replace_whitespace(replacement = " ")
  gsub(/\s+/, replacement)
end

def stringex_convert(options = {}, &block)
  Localization.convert self, options, &block
end

def stringex_default_options
  Stringex::Configuration::StringExtensions.new.settings.marshal_dump
end

def strip_html_tags(leave_whitespace = false)
  string = stringex_convert do
    strip_html_tags!
  end
  leave_whitespace ? string : string.replace_whitespace(' ')
end

def to_ascii
  Stringex::Unidecoder.decode(self)
end

def to_html(lite_mode = false)
  if defined?(RedCloth)
    if lite_mode
      RedCloth.new(self, [:lite_mode]).to_html
    else
      if self =~ /<pre>/
        RedCloth.new(self).to_html.tr("\t", "")
      else
        RedCloth.new(self).to_html.tr("\t", "").gsub(/\n\n/, "")
      end
    end
  else
    warn "String#to_html was called without RedCloth being successfully required"
    self
  end
end

def to_url(options = {})
  return self if options[:exclude] && options[:exclude].include?(self)
  options = stringex_default_options.merge(options)
  whitespace_replacement_token = options[:replace_whitespace_with]
  dummy = remove_formatting(options).
            replace_whitespace(whitespace_replacement_token).
            collapse(whitespace_replacement_token).
            limit(options[:limit], options[:truncate_words], whitespace_replacement_token)
  dummy.downcase! unless options[:force_downcase] == false
  dummy
end

def whole_word_limit(limit, whitespace_replacement_token = "-")
  whole_words = []
  words = self.split(whitespace_replacement_token)
  words.each do |word|
    if word.size > limit
      break
    else
      whole_words << word
      limit -= (word.size + 1)
    end
  end
  whole_words.join(whitespace_replacement_token)
end