implemented reading code graph of deps from compiler manifests

Author: m.malkin

.formatter.exs

@@ -0,0 +1,5 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  line_length: 120
+]

.gitignore

@@ -1,10 +1,24 @@
-/_build
-/cover
-/deps
-/doc
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
 /.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
 erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
 *.ez
-*.beam
-/config/*.secret.exs
-.elixir_ls/
+
+# Ignore package tarball (built via "mix hex.build").
+clean_mixer-*.tar
+

lib/clean_mixer.ex

@@ -0,0 +1,18 @@
+defmodule CleanMixer do
+  @moduledoc """
+  Documentation for CleanMixer.
+  """
+
+  @doc """
+  Hello world.
+
+  ## Examples
+
+      iex> CleanMixer.hello()
+      :world
+
+  """
+  def hello do
+    :world
+  end
+end

lib/clean_mixer/code_graph/dependency.ex

@@ -0,0 +1,23 @@
+defmodule CleanMixer.CodeGraph.Dependency do
+  alias CleanMixer.CodeGraph.SourceFile
+
+  @type type :: :compile | :struct | :runtime
+
+  defstruct [:source, :target, :type]
+
+  @type t :: %__MODULE__{
+          source: SourceFile.t(),
+          target: SourceFile.t(),
+          type: type
+        }
+
+  @spec new(SourceFile.t(), SourceFile.t(), type) :: t
+  def new(source, target, type) do
+    %__MODULE__{source: source, target: target, type: type}
+  end
+
+  defimpl String.Chars do
+    def to_string(dep),
+      do: "#{dep.source.path} -> #{dep.target.path} (#{dep.type})"
+  end
+end

lib/clean_mixer/code_graph/source_file.ex

@@ -0,0 +1,12 @@
+defmodule CleanMixer.CodeGraph.SourceFile do
+  defstruct [:path]
+
+  @type t :: %__MODULE__{
+          path: Path.t()
+        }
+
+  @spec new(Path.t()) :: t
+  def new(path) do
+    %__MODULE__{path: path}
+  end
+end

lib/clean_mixer/compiler_manifests/app.ex

@@ -0,0 +1,39 @@
+defmodule CleanMixer.CompilerManifests.App do
+  alias __MODULE__
+
+  @manifest_filename "compile.elixir"
+
+  defstruct [:path, :name, :manifest_path]
+
+  @type t :: %{
+          path: Path.t(),
+          name: :atom,
+          manifest_path: Path.t()
+        }
+
+  def project_apps() do
+    if Mix.Project.umbrella?() do
+      umbrella_apps()
+    else
+      [current_app()]
+    end
+  end
+
+  defp umbrella_apps do
+    for %{app: app_name, scm: Mix.SCM.Path, opts: opts} <- Mix.Dep.cached(), opts[:from_umbrella] do
+      %App{
+        path: opts[:path],
+        name: app_name,
+        manifest_path: Path.join([opts[:build], ".mix", @manifest_filename])
+      }
+    end
+  end
+
+  defp current_app() do
+    %App{
+      path: "",
+      name: Mix.Project.config() |> Keyword.fetch!(:app),
+      manifest_path: Mix.Project.manifest_path() |> Path.join(@manifest_filename)
+    }
+  end
+end

lib/clean_mixer/compiler_manifests/graph_source.ex

@@ -0,0 +1,30 @@
+defmodule CleanMixer.Xref.CodeGraphSource do
+  alias CleanMixer.CompilerManifests.App
+  alias CleanMixer.CompilerManifests.Manifest
+
+  alias CleanMixer.CodeGraph.Dependency
+  alias CleanMixer.CodeGraph.SourceFile
+
+  def fetch(_options \\ []) do
+    App.project_apps()
+    |> IO.inspect()
+    |> Enum.flat_map(&fetch_for_app/1)
+    |> Enum.reject(&is_nil/1)
+    |> Enum.uniq()
+  end
+
+  defp fetch_for_app(%App{path: app_path} = app) do
+    manifest = Manifest.read_manifest(app)
+
+    for %Manifest.SourceFile{path: path, refs: refs} <- manifest.source_files,
+        %Manifest.Reference{module_name: module_name, type: type} <- refs do
+      callee_module = Manifest.module_for_name(manifest, module_name)
+
+      if callee_module != nil do
+        caller_path = Path.join(app_path, path)
+        callee_path = Path.join(app_path, callee_module.path)
+        Dependency.new(SourceFile.new(caller_path), SourceFile.new(callee_path), type)
+      end
+    end
+  end
+end

lib/clean_mixer/compiler_manifests/manifest.ex

@@ -0,0 +1,83 @@
+defmodule CleanMixer.CompilerManifests.Manifest do
+  alias CleanMixer.CompilerManifests.App
+  require Mix.Compilers.Elixir, as: Compiler
+  alias __MODULE__
+
+  @type module_name :: module()
+
+  defmodule Module do
+    defstruct [:name, :path]
+
+    @type t :: %__MODULE__{
+            name: Manifest.module_name(),
+            path: Path.t()
+          }
+  end
+
+  defmodule Reference do
+    defstruct [:module_name, :type]
+
+    @type ref_type :: :runtime | :struct | :compile
+
+    @type t :: %__MODULE__{
+            module_name: Manifest.module_name(),
+            type: ref_type
+          }
+  end
+
+  defmodule SourceFile do
+    defstruct [:path, :refs]
+
+    @type t :: %__MODULE__{
+            path: Path.t(),
+            refs: list(Reference.t())
+          }
+  end
+
+  defstruct [:modules, :source_files]
+
+  @type t :: %__MODULE__{
+          modules: list(Module.t()),
+          source_files: list(SourceFile.t())
+        }
+
+  def read_manifest(%App{manifest_path: path}) do
+    items = Compiler.read_manifest(path, "")
+
+    %Manifest{
+      modules: manifest_modules(items),
+      source_files: manifest_sources(items)
+    }
+  end
+
+  @spec module_for_name(t(), module_name) :: Module.t() | nil
+  def module_for_name(%Manifest{modules: modules}, module_name) do
+    Enum.find(modules, &(&1.name == module_name))
+  end
+
+  defp manifest_modules(items) do
+    for Compiler.module(sources: [path | _], module: name) <- items do
+      %Module{name: name, path: path}
+    end
+  end
+
+  defp manifest_sources(items) do
+    for Compiler.source(
+          source: path,
+          compile_references: compile_references,
+          struct_references: struct_references,
+          runtime_references: runtime_references
+        ) <- items do
+      references =
+        references_of(:compile, compile_references) ++
+          references_of(:runtime, runtime_references) ++
+          references_of(:struct, struct_references)
+
+      %SourceFile{path: path, refs: references}
+    end
+  end
+
+  defp references_of(type, modules) do
+    modules |> Enum.map(&%Reference{module_name: &1, type: type})
+  end
+end

mix.exs

@@ -0,0 +1,23 @@
+defmodule CleanMixer.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :clean_mixer,
+      version: "0.1.0",
+      elixir: "~> 1.9",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  def application do
+    [
+      extra_applications: [:logger, :mix]
+    ]
+  end
+
+  defp deps do
+    [{:dialyxir, "~> 1.0.0-rc.7", only: [:dev, :test], runtime: false}]
+  end
+end

mix.lock

@@ -0,0 +1,6 @@
+%{
+  "dialyxir": {:hex, :dialyxir, "1.0.0-rc.7", "6287f8f2cb45df8584317a4be1075b8c9b8a69de8eeb82b4d9e6c761cf2664cd", [:mix], [{:erlex, ">= 0.2.5", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm"},
+  "erlang_dot": {:git, "https://github.com/fenollp/erlang-dot.git", "8f2e22e4aa425220e928d669fa6a08d3df1fd4a6", []},
+  "erlex": {:hex, :erlex, "0.2.5", "e51132f2f472e13d606d808f0574508eeea2030d487fc002b46ad97e738b0510", [:mix], [], "hexpm"},
+  "graphvix": {:git, "https://github.com/fenollp/erlang-dot.git", "8f2e22e4aa425220e928d669fa6a08d3df1fd4a6", []},
+}

test/clean_mixer_test.exs

@@ -0,0 +1,8 @@
+defmodule CleanMixerTest do
+  use ExUnit.Case
+  doctest CleanMixer
+
+  test "greets the world" do
+    assert CleanMixer.hello() == :world
+  end
+end

test/test_helper.exs

@@ -0,0 +1 @@
+ExUnit.start()