Convert internal records to structs

Author: José Valim

lib/elixir/lib/hash_dict.ex

@@ -21,6 +21,7 @@ defmodule HashDict do
   @node_size 8
   @node_template :erlang.make_tuple(@node_size, [])
 
+  @opaque t :: map
   defstruct size: 0, root: @node_template
 
   # Inline common instructions

lib/elixir/lib/hash_set.ex

@@ -21,6 +21,7 @@ defmodule HashSet do
   @node_size 8
   @node_template :erlang.make_tuple(@node_size, [])
 
+  @opaque t :: map
   defstruct size: 0, root: @node_template
 
   # Inline common instructions

lib/ex_unit/lib/ex_unit/cli_formatter.ex

@@ -13,7 +13,16 @@ defmodule ExUnit.CLIFormatter do
 
   def init(opts) do
     print_filters(Keyword.take(opts, [:include, :exclude]))
-    {:ok, opts |> Config.new |> add_terminal_width}
+    config = %{
+      seed: opts[:seed],
+      trace: opts[:trace],
+      color: opts[:color],
+      width: get_terminal_width(),
+      tests_counter: 0,
+      failures_counter: 0,
+      invalids_counter: 0
+    }
+    {:ok, config}
   end
 
   def handle_event({:suite_finished, run_us, load_us}, config) do
@@ -32,7 +41,7 @@ defmodule ExUnit.CLIFormatter do
     else
       IO.write success(".", config)
     end
-    {:ok, config.update_tests_counter(&(&1 + 1))}
+    {:ok, %{config | tests_counter: config.tests_counter + 1}}
   end
 
   def handle_event({:test_finished, %ExUnit.Test{state: {:skip, _}} = test}, config) do
@@ -47,8 +56,8 @@ defmodule ExUnit.CLIFormatter do
       IO.write invalid("?", config)
     end
 
-    {:ok, config.update_tests_counter(&(&1 + 1))
-                .update_invalids_counter(&(&1 + 1))}
+    {:ok, %{config | tests_counter: config.tests_counter + 1,
+                     invalids_counter: config.invalids_counter + 1}}
   end
 
   def handle_event({:test_finished, %ExUnit.Test{state: {:failed, failed}} = test}, config) do
@@ -60,8 +69,8 @@ defmodule ExUnit.CLIFormatter do
                                     config.width, &formatter(&1, &2, config))
     print_failure(formatted, config)
 
-    {:ok, config.update_tests_counter(&(&1 + 1))
-                .update_failures_counter(&(&1 + 1))}
+    {:ok, %{config | tests_counter: config.tests_counter + 1,
+                     failures_counter: config.failures_counter + 1}}
   end
 
   def handle_event({:case_started, %ExUnit.TestCase{name: name}}, config) do
@@ -80,7 +89,7 @@ defmodule ExUnit.CLIFormatter do
     formatted = format_test_case_failure(test_case, failed, config.failures_counter + 1,
                                          config.width, &formatter(&1, &2, config))
     print_failure(formatted, config)
-    {:ok, config.update_failures_counter(&(&1 + 1))}
+    {:ok, %{config | failures_counter: config.failures_counter + 1}}
   end
 
   def handle_event(_, config) do
@@ -160,7 +169,7 @@ defmodule ExUnit.CLIFormatter do
 
   # Color styles
 
-  defp colorize(escape, string, Config[color: color]) do
+  defp colorize(escape, string, %{color: color}) do
     IO.ANSI.escape_fragment("%{#{escape}}", color)
       <> string
       <> IO.ANSI.escape_fragment("%{reset}", color)
@@ -183,12 +192,10 @@ defmodule ExUnit.CLIFormatter do
   defp formatter(:location_info, msg, config), do: colorize("bright,black", msg, config)
   defp formatter(_,  msg, _config),            do: msg
 
-  defp add_terminal_width(config) do
+  defp get_terminal_width do
     case :io.columns do
-      {:ok, width} ->
-        config.width(max(40, width))
-      _ ->
-        config
+      {:ok, width} -> max(40, width)
+      _ -> 80
     end
   end
 end

lib/ex_unit/lib/ex_unit/runner.ex

@@ -4,22 +4,29 @@ defmodule ExUnit.Runner do
   alias ExUnit.EventManager, as: EM
   @stop_timeout 30_000
 
-  defrecord Config, max_cases: 4, taken_cases: 0, async_cases: [], seed: nil,
-                    sync_cases: [], include: [], exclude: [], manager: []
-
   def run(async, sync, opts, load_us) do
     opts = normalize_opts(opts)
 
     {:ok, pid} = EM.start_link
     formatters = [ExUnit.RunnerStats|opts[:formatters]]
     Enum.each formatters, &(:ok = EM.add_handler(pid, &1, opts))
 
-    config = Config[manager: pid].update(opts)
+    config = %{
+      seed: opts[:seed],
+      max_cases: opts[:max_cases],
+      sync_cases: [],
+      async_cases: [],
+      taken_cases: 0,
+      include: opts[:include],
+      exclude: opts[:exclude],
+      manager: pid
+    }
 
     {run_us, _} =
       :timer.tc fn ->
         EM.suite_started(config.manager, opts)
-        loop config.async_cases(shuffle(config, async)).sync_cases(shuffle(config, sync))
+        loop %{config | sync_cases: shuffle(config, sync),
+                        async_cases: shuffle(config, async)}
       end
 
     EM.suite_finished(config.manager, run_us, load_us)
@@ -44,7 +51,7 @@ defmodule ExUnit.Runner do
     |> Keyword.put_new(:seed, :erlang.now |> elem(2))
   end
 
-  defp loop(Config[] = config) do
+  defp loop(config) do
     available = config.max_cases - config.taken_cases
 
     cond do
@@ -78,7 +85,7 @@ defmodule ExUnit.Runner do
   defp wait_until_available(config) do
     receive do
       {_pid, :case_finished, _test_case} ->
-        loop config.update_taken_cases(&(&1-1))
+        loop %{config | taken_cases: config.taken_cases - 1}
     end
   end
 
@@ -91,7 +98,7 @@ defmodule ExUnit.Runner do
       end
     end
 
-    loop config.update_taken_cases(&(&1+length(cases)))
+    loop %{config | taken_cases: config.taken_cases + length(cases)}
   end
 
   defp run_case(config, pid, case_name) do
@@ -244,27 +251,27 @@ defmodule ExUnit.Runner do
 
   ## Helpers
 
-  defp shuffle(Config[seed: 0], list) do
+  defp shuffle(%{seed: 0}, list) do
     Enum.reverse(list)
   end
 
-  defp shuffle(Config[seed: seed], list) do
+  defp shuffle(%{seed: seed}, list) do
     :random.seed(3172, 9814, seed)
     Enum.shuffle(list)
   end
 
-  defp take_async_cases(Config[] = config, count) do
+  defp take_async_cases(config, count) do
     case config.async_cases do
       [] -> nil
       cases ->
         {response, remaining} = Enum.split(cases, count)
-        {config.async_cases(remaining), response}
+        {%{config | async_cases: remaining}, response}
     end
   end
 
-  defp take_sync_cases(Config[] = config) do
+  defp take_sync_cases(config) do
     case config.sync_cases do
-      [h|t] -> {config.sync_cases(t), [h]}
+      [h|t] -> {%{config | sync_cases: t}, [h]}
       []    -> nil
     end
   end

lib/ex_unit/lib/ex_unit/server.ex

@@ -4,9 +4,6 @@ defmodule ExUnit.Server do
   @timeout 30_000
   use GenServer.Behaviour
 
-  defrecord Config, async_cases: HashSet.new, sync_cases: HashSet.new,
-                    start_load: nil, captured_devices: HashSet.new
-
   def start_link() do
     :gen_server.start_link({:local, __MODULE__}, __MODULE__, :ok, [])
   end
@@ -44,7 +41,9 @@ defmodule ExUnit.Server do
   ## Callbacks
 
   def init(:ok) do
-    {:ok, Config[]}
+    config = %{async_cases: HashSet.new, sync_cases: HashSet.new,
+               start_load: nil, captured_devices: HashSet.new}
+    {:ok, config}
   end
 
   def handle_call(:start_run, _from, config) do
@@ -55,33 +54,37 @@ defmodule ExUnit.Server do
 
     {:reply,
       {config.async_cases, config.sync_cases, load_us},
-      config.async_cases(HashSet.new).sync_cases(HashSet.new).start_load(nil)}
+      %{config | async_cases: HashSet.new, sync_cases: HashSet.new, start_load: nil}}
   end
 
   def handle_call({:add_device, device}, _from, config) do
     {:reply,
       not(device in config.captured_devices),
-      config.update_captured_devices(&Set.put(&1, device))}
+      %{config | captured_devices: Set.put(config.captured_devices, device)}}
   end
 
   def handle_call({:remove_device, device}, _from, config) do
-    {:reply, :ok, config.update_captured_devices(&Set.delete(&1, device))}
+    {:reply, :ok,
+      %{config | captured_devices: Set.delete(config.captured_devices, device)}}
   end
 
   def handle_call(request, from, config) do
     super(request, from, config)
   end
 
   def handle_cast(:start_load, config) do
-    {:noreply, config.start_load(:os.timestamp)}
+    {:noreply,
+      %{config | start_load: :os.timestamp}}
   end
 
   def handle_cast({:add_async_case, name}, config) do
-    {:noreply, config.update_async_cases &Set.put(&1, name)}
+    {:noreply,
+      %{config | async_cases: Set.put(config.async_cases, name)}}
   end
 
   def handle_cast({:add_sync_case, name}, config) do
-    {:noreply, config.update_sync_cases &Set.put(&1, name)}
+    {:noreply,
+      %{config | sync_cases: Set.put(config.sync_cases, name)}}
   end
 
   def handle_cast(request, config) do