Merge pull request #63 from ukutaht/koan_per_process

Koan per process

lib/display.ex

@@ -33,6 +33,7 @@ defmodule Display do
 
   def considering(module) do
     IO.puts("Considering #{format_module(module)}...")
+    module
   end
 
   def clear_screen do
@@ -42,36 +43,20 @@ defmodule Display do
     end
   end
 
-  defp format_failure(%ExUnit.AssertionError{expr: expr}) do
+  defp format_failure(%{error: %ExUnit.AssertionError{expr: expr}, file: file, line: line}) do
     """
-    #{format_cyan("Assertion failed in #{last_failure_location}")}
+    #{format_cyan("Assertion failed in #{file}:#{line}")}
     #{format_red(Macro.to_string(expr))}
     """
   end
 
-  defp format_failure(error) do
+  defp format_failure(%{error: error, file: file, line: line}) do
     """
-    #{format_cyan("Error in #{last_failure_location}")}
+    #{format_cyan("Error in #{file}:#{line}")}
     #{format_error(error)}
     """
   end
 
-  defp last_failure_location do
-    {file, line} = System.stacktrace
-      |> Enum.drop_while(&in_ex_unit?/1)
-      |> List.first
-      |> extract_file_and_line
-
-    "#{file}:#{line}"
-  end
-
-  defp in_ex_unit?({ExUnit.Assertions, _, _, _}), do: true
-  defp in_ex_unit?(_), do: false
-
-  defp extract_file_and_line({_, _, _, [file: file, line: line]}) do
-    {file, line}
-  end
-
   defp format_error(error) do
     trace = System.stacktrace |> Enum.take(2)
     format_red(Exception.format(:error, error, trace))

lib/execute.ex

@@ -0,0 +1,44 @@
+defmodule Execute do
+  def run_module(module) do
+    Enum.reduce_while(module.all_koans, :passed, fn(koan, _) ->
+      module
+      |> run_koan(koan)
+      |> continue?
+    end)
+  end
+
+  defp continue?(:passed), do: {:cont, :passed}
+  defp continue?(result), do: {:halt, result}
+
+  def run_koan(module, name, args \\ []) do
+    parent = self()
+    spawn(fn -> exec(module, name, args, parent) end)
+    receive do
+      :ok   -> :passed
+      error -> {:failed, error, module, name}
+    end
+  end
+
+  defp exec(module, name, args, parent) do
+    result = apply(module, name, args)
+    send parent, expand(result)
+    Process.exit(self(), :kill)
+  end
+
+  defp expand(:ok), do: :ok
+  defp expand(error) do
+    {file, line} = System.stacktrace
+      |> Enum.drop_while(&in_ex_unit?/1)
+      |> List.first
+      |> extract_file_and_line
+
+      %{error: error, file: file, line: line}
+  end
+
+  defp in_ex_unit?({ExUnit.Assertions, _, _, _}), do: true
+  defp in_ex_unit?(_), do: false
+
+  defp extract_file_and_line({_, _, _, [file: file, line: line]}) do
+   {file, line}
+  end
+end

lib/runner.ex

@@ -14,48 +14,35 @@ defmodule Runner do
     Tasks,
   ]
 
-  def koan?(module) do
-    Enum.member?(@modules, module)
-  end
+  def koan?(koan), do: Enum.member?(@modules, koan)
 
   def run do
     Options.initial_koan
     |>run
   end
 
-  def run(start_module) when start_module in @modules do
+  def run(start_module) when start_module in @modules, do: run(start_module, @modules)
+  def run(start_module), do: Display.invalid_koan(start_module, @modules)
+
+  def run(start_module, modules) do
     Display.clear_screen()
-    start_idx = Enum.find_index(@modules, &(&1 == start_module))
-    Enum.drop(@modules, start_idx)
-    |> Enum.take_while(fn(mod) ->
-      run_module(mod) == :passed
-    end)
+
+    modules
+    |> Enum.drop_while( &(&1 != start_module))
+    |> Enum.take_while( &(run_module(&1) == :passed))
   end
-  def run(koan), do: Display.invalid_koan(koan, @modules)
 
   def run_module(module) do
-    Display.considering(module)
+    module
+    |> Display.considering
+    |> Execute.run_module
+    |> display
 
-    koans = module.all_koans
-    passed = Enum.take_while(koans, fn(name) ->
-      case run_koan(module, name) do
-        :passed -> true
-        {:failed, error, module, name} -> Display.show_failure(error, module, name)
-                                          false
-      end
-    end)
-
-    if Enum.count(koans) == Enum.count(passed) do
-      :passed
-    else
-      :failed
-    end
   end
 
-  def run_koan(module, name, args \\ []) do
-    case apply(module, name, args) do
-      :ok   -> :passed
-      error -> {:failed, error, module, name}
-    end
+  defp display({:failed, error, module, name}) do
+    Display.show_failure(error, module, name)
+    :failed
   end
+  defp display(_), do: :passed
 end