zigler

defmodule Zig.Parser.Unit do
  @moduledoc """
  parses zig code and converts test blocks to test functions
  """

  defstruct tests: [],
    file: nil,
    offset: 0,
    test_dirs: ["./"],
    context: []

  import NimbleParsec

  whitespace = ascii_string([?\s, ?\n], min: 1)
  blankspace = ascii_string([?\s], min: 1)

  @close_paren 41

  defcombinatorp :parenthetical,
    string("(")
    |> repeat(choice([
      parsec(:parenthetical),
      ascii_char(not: @close_paren)]))
    |> string(")")

  init_context = empty()
  |> post_traverse(:init_context)

  # file and line number declaration
  file_line_decl = string("// ref: ")
  |> ascii_string([not: ?\s], min: 1)
  |> string(" line: ")
  |> ascii_string([?0..?9], min: 1)
  |> string("\n")
  |> post_traverse(:parse_file_line_decl)

  # test declaration
  test_decl = ignore(
    string("test")
    |> concat(whitespace)
    |> string("\""))
  |> ascii_string([not: ?\"], min: 1)
  |> ignore(string("\""))
  |> post_traverse(:parse_test_decl)

  # assert statement
  assert_parser = ignore(string("assert("))
  |> repeat(choice([
    parsec(:parenthetical),
    ascii_char(not: @close_paren)]))
  |> ignore(string(")"))
  |> pre_traverse(:parse_assert)

  if Mix.env == :test do
    defparsec :test_parenthetical, parsec(:parenthetical)
    defparsec :test_decl_parser, concat(init_context, test_decl)
    defparsec :test_assert_parser, concat(init_context, assert_parser)
  end

  test_line = optional(blankspace)
  |> concat(test_decl)
  |> concat(whitespace)
  |> string("{")
  |> optional(ascii_string([not: ?\n], min: 1))
  |> string("\n")

  normal_line = optional(
    repeat(choice([
      assert_parser,
      ascii_char(not: ?\n)
    ])))
  |> string("\n")

  unit_code = init_context
  |> repeat(choice([
    file_line_decl,
    test_line,
    normal_line]))

  defparsec :unit_parser, unit_code

  #############################################################################
  ## POST-TRAVERSAL IMPLEMENTATIONS

  # ninjas in a context module for the context map.
  defp init_context(_, _, c, _, _) do
    {[], struct(__MODULE__, Map.put_new(c, :line, 1))}
  end

  defp parse_file_line_decl(_rest, l = [_, line_str, _, file | _], context, {line, _char}, _offset) do
    this_line = String.to_integer(line_str)
    {l, %{context | file: file, offset: this_line - line + 1}}
  end

  defp parse_test_decl(_rest, [test_name], context, _line, _offset) do
    test_nif = new_nif(test_name)
    {["pub fn #{test_nif.name}() !void"],
      %{context | tests: [test_nif | context.tests]}}
  end

  defp parse_assert(_rest, content, context, {line, _char}, _offset) do
    test_content = content |> Enum.reverse |> IO.iodata_to_binary
    rewritten = "try assert(#{test_content}, \"#{context.file}\", #{line + context.offset})"
    {[rewritten], context}
  end

  alias Zig.Parser.Nif
  defp new_nif(name ) do
    %Nif{
      name: String.to_atom("test_#{Zig.Unit.name_to_hash(name)}"),
      test: String.to_atom(name),
      arity: 0,
      args: [],
      retval: "!void"
    }
  end

  #############################################################################
  ## API

  def parse(code, info) do
    case unit_parser(code, []) do
      {:ok, code, _, %{tests: tests}, _, _} ->
        {Enum.map(tests,
          &contextualize(&1, info[:context] || [])),
        code}
      err ->
        raise CompileError, info ++
          [description: "error parsing code in #{info[:file]}: #{inspect err}"]
    end
  end

  defp contextualize(test, context) do
    rename = case context do
      [] -> test.name
      lst -> lst
      |> Kernel.++([test.name])
      |> Enum.join(".")
      |> String.to_atom
    end
    %{test | name: rename}
  end

end