class MarkdownLint::Doc

# File lib/mdl/doc.rb, line 29
def initialize(text, ignore_front_matter = false)
  regex = /\A---\n(.*?)---\n\n?/m
  if ignore_front_matter && regex.match(text)
    @front_matter = regex.match(text).to_s
    @offset = @front_matter.count("\n")
    text.sub!(regex, '')
  else
    @front_matter = ''
    @offset = 0
  end
  # The -1 is to cause split to preserve an extra entry in the array so we
  # can tell if there's a final newline in the file or not.
  @lines = text.split(/\R/, -1)
  @parsed = Kramdown::Document.new(text, :input => 'MarkdownLint')
  @elements = @parsed.root.children
  add_annotations(@elements)
end

# File lib/mdl/doc.rb, line 50
def self.new_from_file(filename, ignore_front_matter = false)
  if filename == '-'
    new($stdin.read.scrub, ignore_front_matter)
  else
    new(
      File.read(filename, :encoding => 'UTF-8').scrub,
      ignore_front_matter,
    )
  end
end

# File lib/mdl/doc.rb, line 140
def element_line(element)
  @lines[element_linenumber(element) - 1]
end

# File lib/mdl/doc.rb, line 129
def element_linenumber(element)
  element = element.options if element.is_a?(Kramdown::Element)
  element[:location]
end

# File lib/mdl/doc.rb, line 148
def element_linenumbers(elements)
  elements.map { |e| element_linenumber(e) }
end

# File lib/mdl/doc.rb, line 156
def element_lines(elements)
  elements.map { |e| element_line(e) }
end

# File lib/mdl/doc.rb, line 280
def extract_as_text(element)
  quotes = {
    :rdquo => '"',
    :ldquo => '"',
    :lsquo => "'",
    :rsquo => "'",
  }
  # If anything goes amiss here, e.g. unknown type, then nil will be
  # returned and we'll just not catch that part of the text, which seems
  # like a sensible failure mode.
  element.children.map do |e|
    if %i{text codespan}.include?(e.type)
      e.value
    elsif %i{strong em p a}.include?(e.type)
      extract_as_text(e).join("\n")
    elsif e.type == :smart_quote
      quotes[e.value]
    end
  end.join.split("\n")
end

# File lib/mdl/doc.rb, line 251
def extract_text(element, prefix = '', restore_whitespace = true)
  quotes = {
    :rdquo => '"',
    :ldquo => '"',
    :lsquo => "'",
    :rsquo => "'",
  }
  # If anything goes amiss here, e.g. unknown type, then nil will be
  # returned and we'll just not catch that part of the text, which seems
  # like a sensible failure mode.
  lines = element.children.map do |e|
    if e.type == :text
      e.value
    elsif %i{strong em p codespan}.include?(e.type)
      extract_text(e, prefix, restore_whitespace).join("\n")
    elsif e.type == :smart_quote
      quotes[e.value]
    end
  end.join.split("\n")
  # Text blocks have whitespace stripped, so we need to add it back in at
  # the beginning. Because this might be in something like a blockquote,
  # we optionally strip off a prefix given to the function.
  lines[0] = element_line(element).sub(prefix, '') if restore_whitespace
  lines
end

# File lib/mdl/doc.rb, line 72
def find_type(type, nested = true)
  find_type_elements(type, nested).map(&:options)
end

# File lib/mdl/doc.rb, line 86
def find_type_elements(type, nested = true, elements = @elements)
  results = []
  type = [type] if type.instance_of?(Symbol)
  elements.each do |e|
    results.push(e) if type.include?(e.type)
    if nested && !e.children.empty?
      results.concat(find_type_elements(type, nested, e.children))
    end
  end
  results
end

# File lib/mdl/doc.rb, line 108
def find_type_elements_except(
  type, nested_except = [], elements = @elements
)
  results = []
  type = [type] if type.instance_of?(Symbol)
  nested_except = [nested_except] if nested_except.instance_of?(Symbol)
  elements.each do |e|
    results.push(e) if type.include?(e.type)
    next if nested_except.include?(e.type) || e.children.empty?

    results.concat(
      find_type_elements_except(type, nested_except, e.children),
    )
  end
  results
end

# File lib/mdl/doc.rb, line 166
def header_style(header)
  if header.type != :header
    raise 'header_style called with non-header element'
  end

  line = element_line(header)
  if line.start_with?('#')
    if line.strip.end_with?('#')
      :atx_closed
    else
      :atx
    end
  else
    :setext
  end
end

# File lib/mdl/doc.rb, line 211
def indent_for(line)
  line.match(/^\s*/)[0].gsub("\t", ' ' * 8).length
end

# File lib/mdl/doc.rb, line 188
def list_style(item)
  raise 'list_style called with non-list element' if item.type != :li

  line = element_line(item).strip.gsub(/^>\s+/, '')
  if line.start_with?('*')
    :asterisk
  elsif line.start_with?('+')
    :plus
  elsif line.start_with?('-')
    :dash
  elsif line.match('[0-9]+\.')
    :ordered
  elsif line.match('[0-9]+\)')
    :ordered_paren
  else
    :unknown
  end
end

# File lib/mdl/doc.rb, line 218
def matching_lines(regex)
  @lines.each_with_index
        .select { |text, _linenum| regex.match(text) }
        .map do |i|
          i[1] + 1
        end
end

# File lib/mdl/doc.rb, line 230
def matching_text_element_lines(regex, exclude_nested = [:a])
  matches = []
  find_type_elements_except(:text, exclude_nested).each do |e|
    first_line = e.options[:location]
    # We'll error out if kramdown doesn't have location information for
    # the current element. It's better to just not match in these cases
    # rather than crash.
    next if first_line.nil?

    lines = e.value.split("\n")
    lines.each_with_index do |l, i|
      matches << (first_line + i) if regex.match(l)
    end
  end
  matches
end

# File lib/mdl/doc.rb, line 303
def to_s
  @front_matter + @lines.join("\n")
end

# File lib/mdl/doc.rb, line 313
def add_annotations(elements, level = 1, parent = nil)
  elements.each do |e|
    e.options[:element_level] = level
    e.options[:parent] = parent
    add_annotations(e.children, level + 1, e)
  end
end