Import phase of Umwelt

Phase

avater sovetnik is working on it

Just imported from binary
In project Umwelt

MindMap

To clone this phase, add umwelt client to your project dependencies in `mix.exs` and run

mix umwelt.clone 44

Terms affected by phase Import phase

In each phase, some terms appeared for the first time, changed their place in the structure, were updated with new meaning, or were marked as no longer in use. These shifts help trace the evolution of the project’s conceptual map.

Added
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, {:__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


Phase History Tree

A tree of all phases the project has passed through to reach the current phase.


Rendering...