Merge pull request #57 from esl/support-options

Support options in mix gradient

Author: Premwoik

.gitignore

@@ -25,4 +25,8 @@ gradient-*.tar
 # Temporary files, for example, from tests.
 /tmp/
 
+# Beam files compiled from examples
+test/examples/_build/
+
+# MacOS DS_Store
 .DS_Store

lib/gradient.ex

@@ -5,6 +5,9 @@ defmodule Gradient do
   Options:
   - `app_path` - Path to the app that contains file with code (for umbrella apps).
   - `code_path` - Path to a file with code (e.g. when beam was compiled without project).
+  - `no_gradualizer_check` - Skip Gradualizer checks if true.
+  - `no_ex_check` - Skip Elixir checks if true.
+  - `no_specify` - Skip AST specifying if true.
   """
 
   alias Gradient.ElixirFileUtils
@@ -20,13 +23,10 @@ defmodule Gradient do
   def type_check_file(file, opts \\ []) do
     opts = Keyword.put(opts, :return_errors, true)
 
-    with {:ok, forms} <- ElixirFileUtils.get_forms_from_beam(file) do
-      forms =
-        forms
-        |> put_code_path(opts)
-        |> AstSpecifier.specify()
+    with {:ok, forms} <- ElixirFileUtils.get_forms(file) do
+      forms = maybe_specify_forms(forms, opts)
 
-      case ElixirChecker.check(forms, opts) ++ :gradualizer.type_check_forms(forms, opts) do
+      case maybe_gradient_check(forms, opts) ++ maybe_gradualizer_check(forms, opts) do
         [] ->
           :ok
 
@@ -42,24 +42,56 @@ defmodule Gradient do
     end
   end
 
+  defp maybe_gradualizer_check(forms, opts) do
+    unless opts[:no_gradualizer_check] do
+      try do
+        :gradualizer.type_check_forms(forms, opts)
+      catch
+        err ->
+          {:attribute, _, :file, {path, _}} = hd(forms)
+          [{path, err}]
+      end
+    else
+      []
+    end
+  end
+
+  defp maybe_gradient_check(forms, opts) do
+    unless opts[:no_ex_check] do
+      ElixirChecker.check(forms, opts)
+    else
+      []
+    end
+  end
+
+  defp maybe_specify_forms(forms, opts) do
+    unless opts[:no_specify] do
+      forms
+      |> put_code_path(opts)
+      |> AstSpecifier.specify()
+    else
+      forms
+    end
+  end
+
   defp put_code_path(forms, opts) do
-    case Keyword.fetch(opts, :code_path) do
-      {:ok, path} ->
-        [{:attribute, 1, :file, {path, 1}} | tl(forms)]
+    case opts[:code_path] do
+      nil ->
+        case opts[:app_path] do
+          nil ->
+            forms
 
-      :error ->
-        case Keyword.fetch(opts, :app_path) do
-          {:ok, app_path} ->
+          app_path ->
             {:attribute, anno, :file, {path, line}} = hd(forms)
 
             [
               {:attribute, anno, :file, {String.to_charlist(app_path) ++ '/' ++ path, line}}
               | tl(forms)
             ]
-
-          :error ->
-            forms
         end
+
+      path ->
+        [{:attribute, 1, :file, {path, 1}} | tl(forms)]
     end
   end
 end

lib/gradient/doublespec.ex

@@ -0,0 +1,17 @@
+defmodule Doublespec do
+  @spec convert(integer()) :: float()
+  @spec convert(atom()) :: binary()
+  def convert(int) when is_integer(int), do: int / 1
+  def convert(atom) when is_atom(atom), do: to_string(atom)
+
+  @spec convert(atom()) :: binary()
+  def last_two(list) do
+    [last, penultimate | _tail] = Enum.reverse(list)
+    [penultimate, last]
+  end
+
+  @spec last_two(atom()) :: atom()
+  def last_three(:ok) do
+    :ok
+  end
+end

lib/gradient/elixir_file_utils.ex

@@ -5,7 +5,7 @@ defmodule Gradient.ElixirFileUtils do
 
   alias Gradient.Types
 
-  @type path() :: :file.filename() | String.t()
+  @type path() :: :file.filename() | binary()
 
   @type abstract_forms() :: [:erl_parse.abstract_form() | :erl_parse.form_info()]
 
@@ -20,9 +20,6 @@ defmodule Gradient.ElixirFileUtils do
   """
   @spec get_forms_from_beam(path()) ::
           {:ok, abstract_forms()} | parsed_file_error()
-  def get_forms_from_beam(path) when is_binary(path),
-    do: get_forms_from_beam(String.to_charlist(path))
-
   def get_forms_from_beam(path) do
     case :beam_lib.chunks(path, [:abstract_code]) do
       {:ok, {_module, [{:abstract_code, {:raw_abstract_v1, forms}}]}} ->
@@ -42,6 +39,36 @@ defmodule Gradient.ElixirFileUtils do
     end
   end
 
+  @spec get_forms_from_ex(binary()) ::
+          {:ok, abstract_forms()} | parsed_file_error()
+  def get_forms_from_ex(path) do
+    # For compiling many files concurrently, see Kernel.ParallelCompiler.compile/2.
+    if File.exists?(path) do
+      [{_module, bin}] = Code.compile_file(path)
+      get_forms_from_beam(bin)
+    else
+      {:file_not_found, path}
+    end
+  end
+
+  def get_forms(path) do
+    case Path.extname(path) do
+      ".beam" ->
+        path
+        |> to_charlist()
+        |> get_forms_from_beam()
+
+      ".ex" ->
+        get_forms_from_ex(path)
+
+      _ ->
+        [path]
+        |> Module.concat()
+        |> :code.which()
+        |> get_forms_from_beam()
+    end
+  end
+
   @spec load_tokens([:erl_parse.abstract_form()]) :: Types.tokens()
   def load_tokens(forms) do
     with [{:attribute, _, :file, {path, _}} | _] <- forms,

lib/gradient/elixir_fmt.ex

@@ -13,6 +13,8 @@ defmodule Gradient.ElixirFmt do
 
   - `ex_fmt_type_fun`: function to pretty print an type AST in Elixir `(abstract_type() -> iodata())`.
 
+  - `{fancy, boolean()}`: do not use fancy error messages, default: true
+
   - Gradualizer options, but some of them are overwritten by Gradient.
   """
   @behaviour Gradient.Fmt
@@ -197,7 +199,7 @@ defmodule Gradient.ElixirFmt do
   def format_location(expression, fmt_type, opts \\ []) do
     case Keyword.get(opts, :fmt_location, :verbose) do
       ^fmt_type -> FmtLib.format_location(expression, fmt_type)
-      :verbose -> ""
+      _ -> ""
     end
   end
 
@@ -244,16 +246,23 @@ defmodule Gradient.ElixirFmt do
   @spec try_highlight_in_context(Types.abstract_expr(), options()) ::
           {:ok, iodata()} | {:error, term()}
   def try_highlight_in_context(expression, opts) do
-    forms = Keyword.get(opts, :forms)
-
-    with :ok <- has_location?(expression),
-         {:ok, path} <- get_ex_file_path(forms),
+    with :ok <- print_fancy?(opts),
+         :ok <- has_location?(expression),
+         {:ok, path} <- get_ex_file_path(opts[:forms]),
          {:ok, code} <- File.read(path) do
       code_lines = String.split(code, ~r/\R/)
       {:ok, highlight_in_context(expression, code_lines, opts)}
     end
   end
 
+  def print_fancy?(opts) do
+    if Keyword.get(opts, :fancy, true) do
+      :ok
+    else
+      {:error, "The fancy mode is turn off"}
+    end
+  end
+
   def has_location?(expression) do
     if elem(expression, 1) == 0 do
       {:error, "The location is missing in the expression"}