zf

plt.ex (6398B)

---

 # Credits: this code was originally part of the `dialyze` task
 # Copyright by James Fish
 # https://github.com/fishcakez/dialyze
 
 defmodule Dialyxir.Plt do
   @moduledoc false
 
   import Dialyxir.Output
   alias Dialyxir.Formatter
 
   def check(plts, fun \\ &check_plt/4) do
     find_plts(plts, [], fun)
   end
 
   defp find_plts([{plt, apps} | plts], acc, fun) do
     case plt_files(plt) do
       nil ->
         find_plts(plts, [{plt, apps, nil} | acc], fun)
 
       beams ->
         apps_rest = Enum.flat_map(plts, fn {_plt2, apps2} -> apps2 end)
         apps = Enum.uniq(apps ++ apps_rest)
         check_plts([{plt, apps, beams} | acc], fun)
     end
   end
 
   defp find_plts([], acc, fun) do
     check_plts(acc, fun)
   end
 
   defp check_plts(plts, fun) do
     _ =
       Enum.reduce(plts, {nil, MapSet.new(), %{}}, fn {plt, apps, beams}, acc ->
         fun.(plt, apps, beams, acc)
       end)
   end
 
   defp check_plt(plt, apps, old_beams, {prev_plt, prev_beams, prev_cache}) do
     info("Finding applications for #{Path.basename(plt)}")
     cache = resolve_apps(apps, prev_cache)
     mods = cache_mod_diff(cache, prev_cache)
     info("Finding modules for #{Path.basename(plt)}")
     beams = resolve_modules(mods, prev_beams)
     check_beams(plt, beams, old_beams, prev_plt)
     {plt, beams, cache}
   end
 
   defp cache_mod_diff(new, old) do
     Enum.flat_map(new, fn {app, {mods, _deps}} ->
       case Map.has_key?(old, app) do
         true -> []
         false -> mods
       end
     end)
   end
 
   defp resolve_apps(apps, cache) do
     apps
     |> Enum.uniq()
     |> Enum.filter(&(not Map.has_key?(cache, &1)))
     |> Enum.map(&app_info/1)
     |> Enum.into(cache)
   end
 
   defp app_info(app) do
     app_file = Atom.to_charlist(app) ++ '.app'
 
     case :code.where_is_file(app_file) do
       :non_existing ->
         error("Unknown application #{inspect(app)}")
         {app, {[], []}}
 
       app_file ->
         Path.expand(app_file)
         |> read_app_info(app)
     end
   end
 
   defp read_app_info(app_file, app) do
     case :file.consult(app_file) do
       {:ok, [{:application, ^app, info}]} ->
         parse_app_info(info, app)
 
       {:error, reason} ->
         Mix.raise("Could not read #{app_file}: #{:file.format_error(reason)}")
     end
   end
 
   defp parse_app_info(info, app) do
     mods = Keyword.get(info, :modules, [])
     apps = Keyword.get(info, :applications, [])
     inc_apps = Keyword.get(info, :included_applications, [])
     runtime_deps = get_runtime_deps(info)
     {app, {mods, runtime_deps ++ inc_apps ++ apps}}
   end
 
   defp get_runtime_deps(info) do
     Keyword.get(info, :runtime_dependencies, [])
     |> Enum.map(&parse_runtime_dep/1)
   end
 
   defp parse_runtime_dep(runtime_dep) do
     runtime_dep = IO.chardata_to_string(runtime_dep)
     regex = ~r/^(.+)\-\d+(?|\.\d+)*$/
     [app] = Regex.run(regex, runtime_dep, capture: :all_but_first)
     String.to_atom(app)
   end
 
   defp resolve_modules(modules, beams) do
     Enum.reduce(modules, beams, &resolve_module/2)
   end
 
   defp resolve_module(module, beams) do
     beam = Atom.to_charlist(module) ++ '.beam'
 
     case :code.where_is_file(beam) do
       path when is_list(path) ->
         path = Path.expand(path)
         MapSet.put(beams, path)
 
       :non_existing ->
         error("Unknown module #{inspect(module)}")
         beams
     end
   end
 
   defp check_beams(plt, beams, nil, prev_plt) do
     plt_ensure(plt, prev_plt)
 
     case plt_files(plt) do
       nil ->
         Mix.raise("Could not open #{plt}: #{:file.format_error(:enoent)}")
 
       old_beams ->
         check_beams(plt, beams, old_beams)
     end
   end
 
   defp check_beams(plt, beams, old_beams, _prev_plt) do
     check_beams(plt, beams, old_beams)
   end
 
   defp check_beams(plt, beams, old_beams) do
     remove = MapSet.difference(old_beams, beams)
     plt_remove(plt, remove)
     check = MapSet.intersection(beams, old_beams)
     plt_check(plt, check)
     add = MapSet.difference(beams, old_beams)
     plt_add(plt, add)
   end
 
   defp plt_ensure(plt, nil), do: plt_new(plt)
   defp plt_ensure(plt, prev_plt), do: plt_copy(prev_plt, plt)
 
   defp plt_new(plt) do
     info("Creating #{Path.basename(plt)}")
     plt = erl_path(plt)
     _ = plt_run(analysis_type: :plt_build, output_plt: plt, apps: [:erts])
     :ok
   end
 
   defp plt_copy(plt, new_plt) do
     info("Copying #{Path.basename(plt)} to #{Path.basename(new_plt)}")
 
     new_plt
     |> Path.dirname()
     |> File.mkdir_p!()
 
     File.cp!(plt, new_plt)
   end
 
   defp plt_add(plt, files) do
     case MapSet.size(files) do
       0 ->
         :ok
 
       n ->
         Mix.shell().info("Adding #{n} modules to #{Path.basename(plt)}")
         plt = erl_path(plt)
         files = erl_files(files)
 
         {duration_us, _} =
           :timer.tc(fn -> plt_run(analysis_type: :plt_add, init_plt: plt, files: files) end)
 
         Mix.shell().info(Formatter.formatted_time(duration_us))
         :ok
     end
   end
 
   defp plt_remove(plt, files) do
     case MapSet.size(files) do
       0 ->
         :ok
 
       n ->
         info("Removing #{n} modules from #{Path.basename(plt)}")
         plt = erl_path(plt)
         files = erl_files(files)
         _ = plt_run(analysis_type: :plt_remove, init_plt: plt, files: files)
         :ok
     end
   end
 
   defp plt_check(plt, files) do
     case MapSet.size(files) do
       0 ->
         :ok
 
       n ->
         Mix.shell().info("Checking #{n} modules in #{Path.basename(plt)}")
         plt = erl_path(plt)
         _ = plt_run(analysis_type: :plt_check, init_plt: plt)
         :ok
     end
   end
 
   defp plt_run(opts) do
     try do
       :dialyzer.run([check_plt: false] ++ opts)
     catch
       {:dialyzer_error, msg} ->
         error(color(":dialyzer.run error: #{msg}", :red))
     end
   end
 
   defp plt_info(plt) do
     erl_path(plt)
     |> :dialyzer.plt_info()
   end
 
   defp erl_files(files) do
     Enum.reduce(files, [], &[erl_path(&1) | &2])
   end
 
   defp erl_path(path) do
     encoding = :file.native_name_encoding()
     :unicode.characters_to_list(path, encoding)
   end
 
   defp plt_files(plt) do
     info("Looking up modules in #{Path.basename(plt)}")
 
     case plt_info(plt) do
       {:ok, info} ->
         Keyword.fetch!(info, :files)
         |> Enum.reduce(MapSet.new(), &MapSet.put(&2, Path.expand(&1)))
 
       {:error, :no_such_file} ->
         nil
 
       {:error, reason} ->
         Mix.raise("Could not open #{plt}: #{:file.format_error(reason)}")
     end
   end
 end