module ActionView::Helpers::TextHelper

def excerpt(text, phrase, options = {})
  return unless text && phrase
  separator = options.fetch(:separator, nil) || ""
  case phrase
  when Regexp
    regex = phrase
  else
    regex = /#{Regexp.escape(phrase)}/i
  end
  return unless matches = text.match(regex)
  phrase = matches[0]
  unless separator.empty?
    text.split(separator).each do |value|
      if value.match?(regex)
        phrase = value
        break
      end
    end
  end
  first_part, second_part = text.split(phrase, 2)
  prefix, first_part   = cut_excerpt_part(:first, first_part, separator, options)
  postfix, second_part = cut_excerpt_part(:second, second_part, separator, options)
  affix = [first_part, separator, phrase, separator, second_part].join.strip
  [prefix, affix, postfix].join
end

def get_cycle(name)
  @_cycles = Hash.new unless defined?(@_cycles)
  @_cycles[name]
end

def highlight(text, phrases, options = {}, &block)
  text = sanitize(text) if options.fetch(:sanitize, true)
  if text.blank? || phrases.blank?
    text || ""
  else
    patterns = Array(phrases).map { |phrase| Regexp === phrase ? phrase : Regexp.escape(phrase) }
    pattern = /(#{patterns.join("|")})/i
    highlighter = options.fetch(:highlighter, '<mark>\1</mark>') unless block
    text.scan(/<[^>]*|[^<]+/).each do |segment|
      if !segment.start_with?("<")
        if block
          segment.gsub!(pattern, &block)
        else
          segment.gsub!(pattern, highlighter)
        end
      end
    end.join
  end.html_safe
end

def pluralize(count, singular, plural_arg = nil, plural: plural_arg, locale: I18n.locale)
  word = if count == 1 || count.to_s.match?(/^1(\.0+)?$/)
    singular
  else
    plural || singular.pluralize(locale)
  end
  "#{count || 0} #{word}"
end

def safe_concat(string)
  output_buffer.respond_to?(:safe_concat) ? output_buffer.safe_concat(string) : concat(string)
end

def set_cycle(name, cycle_object)
  @_cycles = Hash.new unless defined?(@_cycles)
  @_cycles[name] = cycle_object
end

def simple_format(text, html_options = {}, options = {})
  wrapper_tag = options[:wrapper_tag] || "p"
  text = sanitize(text, options.fetch(:sanitize_options, {})) if options.fetch(:sanitize, true)
  paragraphs = split_paragraphs(text)
  if paragraphs.empty?
    content_tag(wrapper_tag, nil, html_options)
  else
    paragraphs.map! { |paragraph|
      content_tag(wrapper_tag, raw(paragraph), html_options)
    }.join("\n\n").html_safe
  end
end

def split_paragraphs(text)
  return [] if text.blank?
  text.to_str.gsub(/\r\n?/, "\n").split(/\n\n+/).map! do |t|
    t.gsub!(/([^\n]\n)(?=[^\n])/, '\1<br />') || t
  end
end

def truncate(text, options = {}, &block)
  if text
    length  = options.fetch(:length, 30)
    content = text.truncate(length, options)
    content = options[:escape] == false ? content.html_safe : ERB::Util.html_escape(content)
    content << capture(&block) if block_given? && text.length > length
    content
  end
end

def word_wrap(text, line_width: 80, break_sequence: "\n")
  return +"" if text.empty?
  # Match up to `line_width` characters, followed by one of
  #   (1) non-newline whitespace plus an optional newline
  #   (2) the end of the string, ignoring any trailing newlines
  #   (3) a newline
  #
  # -OR-
  #
  # Match an empty line
  pattern = /(.{1,#{line_width}})(?:[^\S\n]+\n?|\n*\Z|\n)|\n/
  text.gsub(pattern, "\\1#{break_sequence}").chomp!(break_sequence)
end