add .formatter.exs + format

Author: vise890

.formatter.exs

@@ -0,0 +1,3 @@
+[
+  inputs: ["{config,lib,test}/**/*.{ex,exs}"]
+]

lib/blanks.ex

@@ -1,6 +1,7 @@
 defmodule Blanks do
   def replace(ast, replacements) do
     replacements = List.wrap(replacements)
+
     ast
     |> Macro.prewalk(replacements, &pre/2)
     |> elem(0)
@@ -10,6 +11,7 @@ defmodule Blanks do
     {args, replacements} = Macro.prewalk(args, replacements, &pre_pin/2)
     {put_elem(node, 2, args), replacements}
   end
+
   defp pre({:___, _, _}, [first | remainder]), do: {first, remainder}
   defp pre(node, acc), do: {node, acc}
 
@@ -21,6 +23,7 @@ defmodule Blanks do
       ^unquote(var)
     end
   end
+
   defp pin(var), do: var
 
   def count(ast) do
@@ -29,16 +32,18 @@ defmodule Blanks do
     |> elem(1)
   end
 
-  defp count({:___, _, _} = node, acc), do: {node, acc+1}
+  defp count({:___, _, _} = node, acc), do: {node, acc + 1}
   defp count(node, acc), do: {node, acc}
 
   def replace_line({:__block__, meta, lines}, replacement_fn) do
-    replaced_lines = Enum.map(lines, fn(line) ->
-      replace_line(line, replacement_fn)
-    end)
+    replaced_lines =
+      Enum.map(lines, fn line ->
+        replace_line(line, replacement_fn)
+      end)
 
     {:__block__, meta, replaced_lines}
   end
+
   def replace_line(line, replacement_fn) do
     if count(line) > 0 do
       replacement_fn.(line)

lib/display.ex

@@ -17,33 +17,34 @@ defmodule Display do
   end
 
   def handle_cast(:clear_screen, state = %{clear_screen: true}) do
-    IO.puts(ANSI.clear)
-    IO.puts(ANSI.home)
+    IO.puts(ANSI.clear())
+    IO.puts(ANSI.home())
 
     {:noreply, state}
   end
+
   def handle_cast(:clear_screen, state) do
     {:noreply, state}
   end
 
   def invalid_koan(koan, modules) do
     Notifications.invalid_koan(koan, modules)
-    |> IO.puts
+    |> IO.puts()
   end
 
   def show_failure(failure, module, name) do
     format(failure, module, name)
-    |> IO.puts
+    |> IO.puts()
   end
 
   def show_compile_error(error) do
     Failure.show_compile_error(error)
-    |> IO.puts
+    |> IO.puts()
   end
 
   def congratulate do
-    Notifications.congratulate
-    |> IO.puts
+    Notifications.congratulate()
+    |> IO.puts()
   end
 
   def clear_screen do
@@ -52,16 +53,16 @@ defmodule Display do
 
   defp format(failure, module, name) do
     """
-    #{Intro.intro(module, Tracker.visited)}
+    #{Intro.intro(module, Tracker.visited())}
     Now meditate upon #{format_module(module)}
-    #{ProgressBar.progress_bar(Tracker.summarize)}
+    #{ProgressBar.progress_bar(Tracker.summarize())}
     ----------------------------------------
     #{name}
     #{Failure.format_failure(failure)}
     """
   end
 
   defp format_module(module) do
-    Module.split(module) |> List.last
+    Module.split(module) |> List.last()
   end
 end

lib/display/colours.ex

@@ -5,7 +5,7 @@ defmodule Display.Paint do
   def yellow(str), do: painter().yellow(str)
 
   defp painter do
-    case Mix.env do
+    case Mix.env() do
       :test -> Display.Uncoloured
       _ -> Display.Colours
     end
@@ -15,13 +15,13 @@ end
 defmodule Display.Colours do
   alias IO.ANSI
 
-  def red(str), do: colourize(ANSI.red, str)
-  def cyan(str), do: colourize(ANSI.cyan, str)
-  def green(str), do: colourize(ANSI.green, str)
-  def yellow(str), do: colourize(ANSI.yellow, str)
+  def red(str), do: colourize(ANSI.red(), str)
+  def cyan(str), do: colourize(ANSI.cyan(), str)
+  def green(str), do: colourize(ANSI.green(), str)
+  def yellow(str), do: colourize(ANSI.yellow(), str)
 
   defp colourize(color, message) do
-    Enum.join([color, message, ANSI.reset], "")
+    Enum.join([color, message, ANSI.reset()], "")
   end
 end
 

lib/display/failure.ex

@@ -3,19 +3,25 @@ defmodule Display.Failure do
 
   @no_value :ex_unit_no_meaningful_value
 
-  def format_failure(%{error: %ExUnit.AssertionError{expr: @no_value, message: message}, file: file, line: line}) do
+  def format_failure(%{
+        error: %ExUnit.AssertionError{expr: @no_value, message: message},
+        file: file,
+        line: line
+      }) do
     """
     #{Paint.cyan("Assertion failed in #{file}:#{line}")}
     #{Paint.red(message)}
     """
   end
+
   def format_failure(%{error: %ExUnit.AssertionError{expr: expr} = error, file: file, line: line}) do
     """
     #{Paint.cyan("Assertion failed in #{file}:#{line}")}
     #{Paint.red(Macro.to_string(expr))}
     """
     |> format_inequality(error)
   end
+
   def format_failure(%{error: error, file: file, line: line}) do
     """
     #{Paint.cyan("Error in #{file}:#{line}")}
@@ -26,22 +32,24 @@ defmodule Display.Failure do
   defp format_inequality(message, %{left: @no_value, right: @no_value}) do
     message
   end
+
   defp format_inequality(message, %{left: @no_value, right: match_value}) do
     """
     #{message}
-    value does not match: #{match_value |> inspect |> Paint.yellow}
+    value does not match: #{match_value |> inspect |> Paint.yellow()}
     """
   end
+
   defp format_inequality(message, %{left: left, right: right}) do
     """
     #{message}
-    left:  #{left |> inspect |> Paint.yellow}
-    right: #{right |> inspect |> Paint.yellow}
+    left:  #{left |> inspect |> Paint.yellow()}
+    right: #{right |> inspect |> Paint.yellow()}
     """
   end
 
   defp format_error(error) do
-    trace = System.stacktrace |> Enum.take(2)
+    trace = System.stacktrace() |> Enum.take(2)
     Paint.red(Exception.format(:error, error, trace))
   end
 

lib/display/intro.ex

@@ -2,15 +2,15 @@ defmodule Display.Intro do
   alias Display.Paint
 
   def intro(module, modules) do
-    if not module in modules do
+    if not (module in modules) do
       show_intro(module.intro)
     else
       ""
     end
   end
 
   def show_intro(message) do
-    message <> "\n"
-    |> Paint.green
+    (message <> "\n")
+    |> Paint.green()
   end
 end

lib/display/notification.ex

@@ -15,7 +15,7 @@ defmodule Display.Notifications do
     |> Enum.map(&Atom.to_string/1)
     |> Enum.map(&name/1)
     |> Enum.join(", ")
-    |> Paint.red
+    |> Paint.red()
   end
 
   defp name("Elixir." <> module), do: module

lib/display/progress_bar.ex

@@ -1,5 +1,4 @@
 defmodule Display.ProgressBar do
-
   @progress_bar_length 30
 
   def progress_bar(%{current: current, total: total}) do
@@ -9,11 +8,12 @@ defmodule Display.ProgressBar do
   end
 
   defp calculate_progress(current, total) do
-    round( (current/total) * @progress_bar_length)
+    round(current / total * @progress_bar_length)
   end
 
   defp build_arrow(0), do: ""
+
   defp build_arrow(length) do
-    String.duplicate("=", length-1) <> ">"
+    String.duplicate("=", length - 1) <> ">"
   end
 end

lib/execute.ex

@@ -1,6 +1,6 @@
 defmodule Execute do
-  def run_module(module, callback \\ fn(_result, _module, _koan) -> nil end) do
-    Enum.reduce_while(module.all_koans, :passed, fn(koan, _) ->
+  def run_module(module, callback \\ fn _result, _module, _koan -> nil end) do
+    Enum.reduce_while(module.all_koans, :passed, fn koan, _ ->
       module
       |> run_koan(koan)
       |> hook(module, koan, callback)
@@ -24,31 +24,33 @@ defmodule Execute do
 
   def listen_for_result(module, name) do
     receive do
-      :ok   -> :passed
+      :ok -> :passed
       %{error: _} = failure -> {:failed, failure, module, name}
       _ -> listen_for_result(module, name)
     end
   end
 
   defp exec(module, name, args, parent) do
     result = apply(module, name, args)
-    send parent, expand(result, module)
+    send(parent, expand(result, module))
     Process.exit(self(), :kill)
   end
 
   defp expand(:ok, _), do: :ok
+
   defp expand(error, module) do
-    {file, line} = System.stacktrace
-      |> Enum.drop_while(&!in_koan?(&1, module))
-      |> List.first
+    {file, line} =
+      System.stacktrace()
+      |> Enum.drop_while(&(!in_koan?(&1, module)))
+      |> List.first()
       |> extract_file_and_line
 
-      %{error: error, file: file, line: line}
+    %{error: error, file: file, line: line}
   end
 
   defp in_koan?({module, _, _, _}, koan), do: module == koan
 
   defp extract_file_and_line({_, _, _, [file: file, line: line]}) do
-   {file, line}
+    {file, line}
   end
 end

lib/koans.ex

@@ -29,8 +29,10 @@ defmodule Koans do
   end
 
   defmacro generate_test_method(_name, 0, _body), do: false
+
   defmacro generate_test_method(name, 1, body) do
     single_var = Blanks.replace(body, Macro.var(:answer, __MODULE__))
+
     quote do
       def unquote(name)(answer) do
         try do
@@ -42,8 +44,11 @@ defmodule Koans do
       end
     end
   end
+
   defmacro generate_test_method(name, number_of_args, body) do
-    answer_vars = for id <- 1..number_of_args, do: Macro.var(String.to_atom("answer#{id}"), __MODULE__)
+    answer_vars =
+      for id <- 1..number_of_args, do: Macro.var(String.to_atom("answer#{id}"), __MODULE__)
+
     multi_var = Blanks.replace(body, answer_vars)
 
     quote do
@@ -60,12 +65,12 @@ defmodule Koans do
 
   defp blank_line_replacement({:assert, _meta, [expr]}) do
     code = Macro.escape(expr)
-    quote do: raise ExUnit.AssertionError, expr: unquote(code)
+    quote do: raise(ExUnit.AssertionError, expr: unquote(code))
   end
 
   defp blank_line_replacement(line) do
     code = Macro.escape(line)
-    quote do: raise ExUnit.AssertionError, expr: unquote(code)
+    quote do: raise(ExUnit.AssertionError, expr: unquote(code))
   end
 
   defmacro __using__(_opts) do
@@ -83,6 +88,7 @@ defmodule Koans do
 
   defmacro __before_compile__(env) do
     koans = koans(env)
+
     quote do
       def all_koans do
         unquote(koans)
@@ -95,6 +101,6 @@ defmodule Koans do
   defp koans(env) do
     env.module
     |> Module.get_attribute(:koans)
-    |> Enum.reverse
+    |> Enum.reverse()
   end
 end

lib/koans/01_equalities.ex

@@ -1,7 +1,7 @@
 defmodule Equalities do
   use Koans
 
-  @intro  """
+  @intro """
   Welcome to the Elixir koans.
   Let these be your first humble steps towards learning a new language.
 

lib/koans/04_atoms.ex

@@ -11,12 +11,12 @@ defmodule Atoms do
   koan "It is surprising to find out that booleans are atoms" do
     assert is_atom(true) == ___
     assert is_boolean(false) == ___
-    assert :true == ___
-    assert :false == ___
+    assert true == ___
+    assert false == ___
   end
 
   koan "Like booleans, the nil value is also an atom" do
     assert is_atom(nil) == ___
-    assert :nil == ___
+    assert nil == ___
   end
 end

lib/koans/08_maps.ex

@@ -6,13 +6,11 @@ defmodule Maps do
   @person %{
     first_name: "Jon",
     last_name: "Snow",
-    age: 27,
+    age: 27
   }
 
   koan "Maps represent structured data, like a person" do
-    assert @person == %{first_name: ___,
-                        last_name: "Snow",
-                        age: 27 }
+    assert @person == %{first_name: ___, last_name: "Snow", age: 27}
   end
 
   koan "Fetching a value returns a tuple with ok when it exists" do