defmodule Umwelt.Files do
  @moduledoc "Finds elixir files recursive from dir"
  @elixirc_paths Mix.Project.config()[:elixirc_paths]
  @doc "Head of list_root_dir/1"
  @spec list_root_dir(project :: any) :: any
  def list_root_dir(project)

  def list_root_dir(project) do
  end

  @doc "Head of root_module/1"
  @spec root_module(project :: any) :: any
  def root_module(project)

  def root_module(project) do
  end
end

defmodule Umwelt.FilesTest do
  use ExUnit.Case, async: true
  alias Umwelt.Files

  describe("list_root_dir / 1") do
    test "fun list_root_dir" do
    end
  end

  describe("root_module / 1") do
    test "fun root_module" do
    end
  end
end

defmodule Mix do
end

defmodule Mix do
end

defmodule Umwelt.Parser do
  @moduledoc "Extracts metadata from AST"
  @doc "Head of maybe_list_parse/2"
  @spec maybe_list_parse(ast :: any, aliases :: any) :: any
  def maybe_list_parse(ast, aliases)
  @doc "maybe_list_parse when is_list"
  def maybe_list_parse(ast, aliases) when is_list(ast) do
  end

  def maybe_list_parse(ast, aliases) do
  end

  @doc "Head of parse/2"
  @spec parse(ast :: any, _aliases :: any) :: any
  def parse(ast, _aliases)
  @doc "parse when is_macro"
  def parse(ast, aliases) when is_macro(ast) do
  end

  def parse(ast, _aliases) do
  end

  @doc "parse when is_list"
  def parse(ast, aliases) when is_list(ast) do
  end

  def parse(ast, _aliases) do
  end

  @doc "Head of parse_ast/1"
  @spec parse_ast(tuple :: tuple) :: any
  def parse_ast(tuple)

  def parse_ast(tuple) do
  end

  @doc "Head of parse_list/2"
  @spec parse_list(ast :: any, aliases :: any) :: any
  def parse_list(ast, aliases)
  @doc "parse_list when is_list"
  def parse_list(ast, aliases) when is_list(ast) do
  end

  @doc "Head of parse_raw/1"
  @spec parse_raw(code :: any) :: any
  def parse_raw(code)

  def parse_raw(code) do
  end

  @doc "Head of parse_root/1"
  @spec parse_root(tuple :: tuple) :: any
  def parse_root(tuple)

  def parse_root(tuple) do
  end

  @doc "Head of parse_source/1"
  @spec parse_source(project :: any) :: any
  def parse_source(project)

  def parse_source(project) do
  end

  @doc "Head of read_ast/1"
  @spec read_ast(code :: any) :: any
  def read_ast(code)

  def read_ast(code) do
  end

  def read_ast(code) do
  end

  @doc "read_ast when is_binary"
  def read_ast(code) when is_binary(code) do
  end
end

defmodule Umwelt.ParserTest do
  use ExUnit.Case, async: true
  alias Umwelt.Parser

  describe("maybe_list_parse / 2") do
    test "fun maybe_list_parse" do
    end
  end

  describe("parse / 2") do
    test "fun parse" do
    end

    test "fun parse" do
    end
  end

  describe("parse_ast / 1") do
    test "fun parse_ast" do
    end
  end

  describe("parse_list / 2") do
  end

  describe("parse_raw / 1") do
    test "fun parse_raw" do
    end
  end

  describe("parse_root / 1") do
    test "fun parse_root" do
    end
  end

  describe("parse_source / 1") do
    test "fun parse_source" do
    end
  end

  describe("read_ast / 1") do
    test "fun read_ast" do
    end

    test "fun read_ast" do
    end
  end
end

defmodule Enum do
end

defmodule Enum do
end

defmodule String do
end

defmodule String do
end