Phase Import phase by sovetnik active
Project: Umwelt 0.3

Import phase

Just imported from binary

Back to project | MindMap

To clone this phase add umwelt to your project deps and run


New
external List created

External dependency List

lib/list.ex 
defmodule List do
end
test/list_test.exs 
defmodule List do
end

protocol Argument created

All about types

lib/umwelt/argument.ex 
defprotocol(Umwelt.Argument) do
  @moduledoc "All about types"
  @doc "Head of resolve/2"
  @spec resolve(any, any) :: any
  def resolve(left, right)
end
test/umwelt/argument_test.exs 
defprotocol(Umwelt.Argument) do
  @moduledoc "All about types"
  @doc "Head of resolve/2"
  @spec resolve(any, any) :: any
  def resolve(left, right)
end

concept Client created

Client for umwelt.dev

lib/umwelt/client.ex 
defmodule Umwelt.Client do
  @moduledoc "Client for umwelt.dev"
  @doc "Head of pull/1"
  @spec pull(any) :: any
  def pull(params) do
  end
end
test/umwelt/client_test.exs 
defmodule Umwelt.ClientTest do
  use ExUnit.Case, async: true

  describe("pull / 1") do
    test "" do
    end
  end
end

concept Felixir created

Safe Elixir -> saFe elixir -> Felixir

lib/umwelt/felixir.ex 
defmodule Umwelt.Felixir do
  @moduledoc "Safe Elixir  -> saFe elixir  -> Felixir"
end
test/umwelt/felixir_test.exs 
defmodule Umwelt.FelixirTest do
  use ExUnit.Case, async: true
end

concept Files created

Finds elixir files recursive from dir

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

  @doc "Head of list_root_dir/1"
  @spec list_root_dir(any) :: any
  def list_root_dir(project) do
  end

  @doc "Head of filter_root_files/2"
  @spec filter_root_files(any, any) :: any
  def filter_root_files(path, project) do
  end

  @doc "Head of files_in/1"
  @spec files_in(any) :: any
  def files_in(path) do
  end

  @doc "Head of do_files_in/2"
  @spec do_files_in(boolean, any) :: any
  def do_files_in(false, path)

  def do_files_in(false, path) do
  end

  def do_files_in(true, path) do
  end
end
test/umwelt/files_test.exs 
defmodule Umwelt.FilesTest do
  use ExUnit.Case, async: true
  alias Mix.Project

  describe("do_files_in / 2") do
    test "arg #1 is false (boolean)" do
    end

    test "arg #1 is true (boolean)" do
    end
  end

  describe("files_in / 1") do
    test "" do
    end
  end

  describe("filter_root_files / 2") do
    test "" do
    end
  end

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

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

external Mix created

External dependency Mix

lib/mix.ex 
defmodule Mix do
end
test/mix_test.exs 
defmodule Mix do
end

concept Parser created

Extracts metadata from AST

lib/umwelt/parser.ex 
defmodule Umwelt.Parser do
  @moduledoc "Extracts metadata from AST"
  alias Umwelt.Parser
  @doc "Head of read_ast/1"
  @spec read_ast(tuple) :: any
  def read_ast(tuple)

  def read_ast({:ok, code}) do
  end

  def read_ast({:error, msg}) do
  end

  def read_ast(tuple) when is_binary(code) do
  end

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

  @doc "Head of parse_root_source/1"
  @spec parse_root_source(any) :: any
  def parse_root_source(project) do
  end

  @doc "Head of parse_root/1"
  @spec parse_root(tuple) :: any
  def parse_root({:ok, ast}) do
  end

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

  @doc "Head of parse_other_sources/1"
  @spec parse_other_sources(any) :: any
  def parse_other_sources(project) do
  end

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

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

  def parse_ast({:error, _}) do
  end

  def parse_ast({:ok, {:__block__, _, []}}) do
  end

  def parse_ast({:ok, match({:__block__, _, _}, block)}) do
  end

  def parse_ast({:ok, ast}) do
  end

  @doc "Head of parse/3"
  @spec parse(tuple, any, any) :: any
  def parse(ast, aliases, context)

  def parse(ast, aliases, context) when is_macro(ast) do
  end

  def parse(ast, aliases, context) do
  end

  def parse(ast, aliases, context) when is_list(ast) do
  end

  def parse(ast, aliases, context) do
  end

  @doc "Head of maybe_list_parse/3"
  @spec maybe_list_parse(any, any, any) :: any
  def maybe_list_parse(ast, aliases, context)

  def maybe_list_parse(ast, aliases, context) when is_list(ast) do
  end

  def maybe_list_parse(ast, aliases, context) do
  end

  @doc "Head of index_root/1"
  @spec index_root(any) :: any
  def index_root(parsed) do
  end

  @doc "Head of index_deep/1"
  @spec index_deep(any) :: any
  def index_deep(parsed) do
  end
end
test/umwelt/parser_test.exs 
defmodule Umwelt.ParserTest do
  use ExUnit.Case, async: true
  alias Umwelt.Parser

  describe("index_deep / 1") do
    test "" do
    end
  end

  describe("index_root / 1") do
    test "" do
    end
  end

  describe("maybe_list_parse / 3") do
    test "when is_list(ast)" do
    end

    test "" do
    end
  end

  describe("parse / 3") do
    test "when is_macro(ast)" do
    end

    test "" do
    end

    test "when is_list(ast)" do
    end

    test "" do
    end
  end

  describe("parse_ast / 1") do
    test "arg #1 is tuple" do
    end

    test "arg #1 is tuple" do
    end

    test "arg #1 is tuple" do
    end

    test "arg #1 is tuple" do
    end
  end

  describe("parse_list / 3") do
    test "when is_list(ast)" do
    end
  end

  describe("parse_other_sources / 1") do
    test "" do
    end
  end

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

  describe("parse_root / 1") do
    test "arg #1 is tuple" do
    end
  end

  describe("parse_root_source / 1") do
    test "" do
    end
  end

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

  describe("read_ast / 1") do
    test "arg #1 is tuple" do
    end

    test "arg #1 is tuple" do
    end

    test "when is_binary(code)" do
    end
  end
end

operator union created

atom | tuple

lib/umwelt.ex 
|()
test/umwelt_test.exs 
|()

operator union created

boolean | tuple

lib/umwelt.ex 
|()
test/umwelt_test.exs 
|()

operator union created

atom | boolean | tuple

lib/umwelt.ex 
|()
test/umwelt_test.exs 
|()

external Enum created

External dependency Enum

lib/enum.ex 
defmodule Enum do
end
test/enum_test.exs 
defmodule Enum do
end

external String created

External dependency String

lib/string.ex 
defmodule String do
end
test/string_test.exs 
defmodule String do
end

operator union created

list | tuple

lib/umwelt.ex 
|()
test/umwelt_test.exs 
|()

external Call created

External dependency Call

lib/call.ex 
defmodule Call do
end
test/call_test.exs 
defmodule Call do
end

external Structure created

External dependency Structure

lib/structure.ex 
defmodule Structure do
end
test/structure_test.exs 
defmodule Structure do
end

external Variable created

External dependency Variable

lib/variable.ex 
defmodule Variable do
end
test/variable_test.exs 
defmodule Variable do
end

external Literal created

External dependency Literal

lib/literal.ex 
defmodule Literal do
end
test/literal_test.exs 
defmodule Literal do
end

external Alias created

External dependency Alias

lib/alias.ex 
defmodule Alias do
end
test/alias_test.exs 
defmodule Alias do
end


Rendering...