Introduce global state for options so we don't have to pass it around

lib/display.ex

@@ -2,8 +2,8 @@ defmodule Display do
   alias IO.ANSI
   @current_dir File.cwd!
 
-  def show_failure(%{expr: expr}, module, name, options) do
-    clear_screen(options)
+  def show_failure(%{expr: expr}, module, name) do
+    clear_screen()
 
     IO.puts("Now meditate upon #{display_module(module)}")
     IO.puts("---------------------------------------")
@@ -16,10 +16,11 @@ defmodule Display do
     IO.puts("Considering #{display_module(module)}...")
   end
 
-  def clear_screen(%{ clear_screen: false }), do: false
-  def clear_screen(_) do
-    IO.puts(ANSI.clear)
-    IO.puts(ANSI.home)
+  def clear_screen() do
+    if Options.clear_screen? do
+      IO.puts(ANSI.clear)
+      IO.puts(ANSI.home)
+    end
   end
 
   def display_failed_assertion(module, expr) do

lib/meditate.ex

@@ -7,8 +7,8 @@ defmodule Mix.Tasks.Meditate do
     Code.compiler_options(ignore_module_conflict: true)
     Watcher.start
 
-    options = Options.parse(args)
-    Runner.run(options)
+    Options.parse(args)
+    Runner.run
 
     :timer.sleep(:infinity)
   end

lib/options.ex

@@ -1,16 +1,22 @@
 defmodule Options do
+  @defaults %{
+    clear_screen: false
+  }
 
-  def parse([]), do: defaults
   def parse(args) do
-    Enum.reduce(args, defaults, fn(arg, acc) ->
+    options = Enum.reduce(args, @defaults, fn(arg, acc) ->
       Map.merge(acc, parse_argument(arg))
     end)
+
+    Agent.start_link(fn -> options end, name: __MODULE__)
+  end
+
+  def clear_screen? do
+    Agent.get(__MODULE__, fn(options) ->
+      Map.fetch!(options, :clear_screen)
+    end)
   end
 
   def parse_argument("--clear-screen"), do: %{ clear_screen: true}
   def parse_argument(_), do: %{}
-
-  defp defaults do
-    %{ clear_screen: false}
-  end
 end

lib/runner.ex

@@ -10,25 +10,25 @@ defmodule Runner do
     Structs
   ]
 
-  def run(options) do
-    run(Equalities, options)
+  def run do
+    run(Equalities)
   end
 
-  def run(start_module, options) do
+  def run(start_module) do
     start_idx = Enum.find_index(@modules, &(&1 == start_module))
     Enum.drop(@modules, start_idx)
     |> Enum.take_while(fn(mod) ->
-      run_module(mod, options) == :passed
+      run_module(mod) == :passed
     end)
   end
 
-  def run_module(module, options) do
+  def run_module(module) do
     Display.considering(module)
 
     koans = extract_koans_from(module)
 
     passed = Enum.take_while(koans, fn(name) ->
-      run_koan(module, name, options) == :passed
+      run_koan(module, name) == :passed
     end)
 
     if Enum.count(koans) == Enum.count(passed) do
@@ -38,11 +38,11 @@ defmodule Runner do
     end
   end
 
-  def run_koan(module, name, options) do
+  def run_koan(module, name) do
     case apply(module, name, []) do
       :ok   -> :passed
       error ->
-        Display.show_failure(error, module, name, options)
+        Display.show_failure(error, module, name)
         :failed
     end
   end

test/options_test.exs

@@ -2,17 +2,17 @@ defmodule OptionTest do
   use ExUnit.Case, async: true
 
   test "has default options" do
-    options = Options.parse([])
-    refute Map.fetch!(options, :clear_screen)
+    Options.parse([])
+    refute Options.clear_screen?
   end
 
   test "override clearing of screen" do
-    options = Options.parse(["--clear-screen"])
-    assert Map.fetch!(options, :clear_screen)
+    Options.parse(["--clear-screen"])
+    assert Options.clear_screen?
   end
 
   test "ignores unknown options" do
     options = Options.parse(["--foo"])
-    refute Map.fetch!(options, :clear_screen)
+    refute Options.clear_screen?
   end
 end