trackler 2.2.1.109 → 2.2.1.110

data/tracks/elixir/exercises/etl/etl.exs

@@ -9,6 +9,5 @@ defmodule ETL do
   """
   @spec transform(map) :: map
   def transform(input) do
-
   end
 end

data/tracks/elixir/exercises/etl/etl_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("etl.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule TransformTest do
   use ExUnit.Case
@@ -27,6 +27,7 @@ defmodule TransformTest do
   @tag :pending
   test "more keys" do
     old = %{1 => ["APPLE", "ARTICHOKE"], 2 => ["BOAT", "BALLERINA"]}
+
     expected = %{
       "apple" => 1,
       "artichoke" => 1,
@@ -40,21 +41,41 @@ defmodule TransformTest do
   @tag :pending
   test "full dataset" do
     old = %{
-      1 =>  ~W(A E I O U L N R S T),
-      2 =>  ~W(D G),
-      3 =>  ~W(B C M P),
-      4 =>  ~W(F H V W Y),
-      5 =>  ~W(K),
-      8 =>  ~W(J X),
+      1 => ~W(A E I O U L N R S T),
+      2 => ~W(D G),
+      3 => ~W(B C M P),
+      4 => ~W(F H V W Y),
+      5 => ~W(K),
+      8 => ~W(J X),
       10 => ~W(Q Z)
     }
 
     expected = %{
-      "a" => 1, "b" => 3,  "c" => 3, "d" => 2, "e" => 1,
-      "f" => 4, "g" => 2,  "h" => 4, "i" => 1, "j" => 8,
-      "k" => 5, "l" => 1,  "m" => 3, "n" => 1, "o" => 1,
-      "p" => 3, "q" => 10, "r" => 1, "s" => 1, "t" => 1,
-      "u" => 1, "v" => 4,  "w" => 4, "x" => 8, "y" => 4,
+      "a" => 1,
+      "b" => 3,
+      "c" => 3,
+      "d" => 2,
+      "e" => 1,
+      "f" => 4,
+      "g" => 2,
+      "h" => 4,
+      "i" => 1,
+      "j" => 8,
+      "k" => 5,
+      "l" => 1,
+      "m" => 3,
+      "n" => 1,
+      "o" => 1,
+      "p" => 3,
+      "q" => 10,
+      "r" => 1,
+      "s" => 1,
+      "t" => 1,
+      "u" => 1,
+      "v" => 4,
+      "w" => 4,
+      "x" => 8,
+      "y" => 4,
       "z" => 10
     }
 

data/tracks/elixir/exercises/etl/example.exs

@@ -9,15 +9,15 @@ defmodule ETL do
   """
   def transform(input) do
     input
-      |> Map.to_list
-      |> invert
-      |> List.flatten
-      |> Enum.into(%{})
+    |> Map.to_list()
+    |> invert
+    |> List.flatten()
+    |> Enum.into(%{})
   end
 
   defp invert(pairs) do
-    Enum.map(pairs, fn({key, values}) ->
-      Enum.map(values, fn(value) -> {String.downcase(value), key} end)
+    Enum.map(pairs, fn {key, values} ->
+      Enum.map(values, fn value -> {String.downcase(value), key} end)
     end)
   end
 end

data/tracks/elixir/exercises/flatten-array/flatten_array.exs

@@ -14,6 +14,5 @@ defmodule FlattenArray do
 
   @spec flatten(list) :: list
   def flatten(list) do
-
   end
 end

data/tracks/elixir/exercises/flatten-array/flatten_array_test.exs

@@ -2,38 +2,38 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("flatten_array.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule FlattenArrayTest do
   use ExUnit.Case
 
   test "returns original list if there is nothing to flatten" do
-    assert FlattenArray.flatten([1, 2, 3]) ==  [1, 2, 3]
+    assert FlattenArray.flatten([1, 2, 3]) == [1, 2, 3]
   end
 
   @tag :pending
   test "flattens an empty nested list" do
-    assert FlattenArray.flatten([[]]) ==  []
+    assert FlattenArray.flatten([[]]) == []
   end
 
   @tag :pending
   test "flattens a nested list" do
-    assert FlattenArray.flatten([1,[2,[3],4],5,[6,[7,8]]]) == [1, 2, 3, 4, 5, 6, 7, 8]
+    assert FlattenArray.flatten([1, [2, [3], 4], 5, [6, [7, 8]]]) == [1, 2, 3, 4, 5, 6, 7, 8]
   end
 
   @tag :pending
   test "removes nil from list" do
-    assert FlattenArray.flatten([1, nil, 2]) ==  [1, 2]
+    assert FlattenArray.flatten([1, nil, 2]) == [1, 2]
   end
 
   @tag :pending
   test "removes nil from a nested list" do
-    assert FlattenArray.flatten([1, [2, nil, 4], 5]) ==  [1, 2, 4, 5]
+    assert FlattenArray.flatten([1, [2, nil, 4], 5]) == [1, 2, 4, 5]
   end
 
   @tag :pending
   test "returns an empty list if all values in nested list are nil" do
-    assert FlattenArray.flatten([nil, [nil], [nil, [nil]]]) ==  []
+    assert FlattenArray.flatten([nil, [nil], [nil, [nil]]]) == []
   end
 end

data/tracks/elixir/exercises/forth/example.exs

@@ -135,11 +135,11 @@ defmodule Forth do
     Regex.scan(~r/[\p{L}\p{N}\p{S}\p{P}]+/u, s)
     |> Stream.map(&hd/1)
     |> Enum.map(fn t ->
-         case Integer.parse(t) do
-           {i, ""} -> i
-           _ -> t
-         end
-       end)
+      case Integer.parse(t) do
+        {i, ""} -> i
+        _ -> t
+      end
+    end)
   end
 
   @doc """

data/tracks/elixir/exercises/forth/forth.exs

@@ -6,24 +6,21 @@ defmodule Forth do
   """
   @spec new() :: evaluator
   def new() do
-
   end
 
   @doc """
   Evaluate an input string, updating the evaluator state.
   """
-  @spec eval(evaluator, String.t) :: evaluator
+  @spec eval(evaluator, String.t()) :: evaluator
   def eval(ev, s) do
-
   end
 
   @doc """
   Return the current stack as a string with the element on top of the stack
   being the rightmost element in the string.
   """
-  @spec format_stack(evaluator) :: String.t
+  @spec format_stack(evaluator) :: String.t()
   def format_stack(ev) do
-
   end
 
   defmodule StackUnderflow do
@@ -32,13 +29,13 @@ defmodule Forth do
   end
 
   defmodule InvalidWord do
-    defexception [word: nil]
-    def message(e), do: "invalid word: #{inspect e.word}"
+    defexception word: nil
+    def message(e), do: "invalid word: #{inspect(e.word)}"
   end
 
   defmodule UnknownWord do
-    defexception [word: nil]
-    def message(e), do: "unknown word: #{inspect e.word}"
+    defexception word: nil
+    def message(e), do: "unknown word: #{inspect(e.word)}"
   end
 
   defmodule DivisionByZero do

data/tracks/elixir/exercises/forth/forth_test.exs

@@ -2,167 +2,210 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("forth.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule ForthTest do
   use ExUnit.Case
 
   # @tag :pending
   test "no input, no stack" do
-    s = Forth.new |> Forth.format_stack
+    s = Forth.new() |> Forth.format_stack()
     assert s == ""
   end
 
   @tag :pending
   test "numbers just get pushed onto the stack" do
-    s = Forth.new
-        |> Forth.eval("1 2 3 4 5")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 3 4 5")
+      |> Forth.format_stack()
+
     assert s == "1 2 3 4 5"
   end
 
   @tag :pending
   test "non-word characters are separators" do
     # Note the Ogham Space Mark ( ), this is a spacing character.
-    s = Forth.new
-        |> Forth.eval("1\x002\x013\n4\r5 6\t7")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval("1\x002\x013\n4\r5 6\t7")
+      |> Forth.format_stack()
+
     assert s == "1 2 3 4 5 6 7"
   end
 
   @tag :pending
   test "basic arithmetic" do
-    s = Forth.new
-        |> Forth.eval("1 2 + 4 -")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 + 4 -")
+      |> Forth.format_stack()
+
     assert s == "-1"
-    s = Forth.new
-        |> Forth.eval("2 4 * 3 /") # integer division
-        |> Forth.format_stack
+    # integer division
+    s =
+      Forth.new()
+      |> Forth.eval("2 4 * 3 /")
+      |> Forth.format_stack()
+
     assert s == "2"
   end
 
   @tag :pending
   test "division by zero" do
     assert_raise Forth.DivisionByZero, fn ->
-      Forth.new |> Forth.eval("4 2 2 - /")
+      Forth.new() |> Forth.eval("4 2 2 - /")
     end
   end
 
   @tag :pending
   test "dup" do
-    s = Forth.new
-        |> Forth.eval("1 DUP")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval("1 DUP")
+      |> Forth.format_stack()
+
     assert s == "1 1"
-    s = Forth.new
-        |> Forth.eval("1 2 Dup")
-        |> Forth.format_stack
+
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 Dup")
+      |> Forth.format_stack()
+
     assert s == "1 2 2"
+
     assert_raise Forth.StackUnderflow, fn ->
-      Forth.new |> Forth.eval("dup")
+      Forth.new() |> Forth.eval("dup")
     end
   end
 
   @tag :pending
   test "drop" do
-    s = Forth.new
-        |> Forth.eval("1 drop")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval("1 drop")
+      |> Forth.format_stack()
+
     assert s == ""
-    s = Forth.new
-        |> Forth.eval("1 2 drop")
-        |> Forth.format_stack
+
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 drop")
+      |> Forth.format_stack()
+
     assert s == "1"
+
     assert_raise Forth.StackUnderflow, fn ->
-      Forth.new |> Forth.eval("drop")
+      Forth.new() |> Forth.eval("drop")
     end
   end
 
   @tag :pending
   test "swap" do
-    s = Forth.new
-        |> Forth.eval("1 2 swap")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 swap")
+      |> Forth.format_stack()
+
     assert s == "2 1"
-    s = Forth.new
-        |> Forth.eval("1 2 3 swap")
-        |> Forth.format_stack
+
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 3 swap")
+      |> Forth.format_stack()
+
     assert s == "1 3 2"
+
     assert_raise Forth.StackUnderflow, fn ->
-      Forth.new |> Forth.eval("1 swap")
+      Forth.new() |> Forth.eval("1 swap")
     end
+
     assert_raise Forth.StackUnderflow, fn ->
-      Forth.new |> Forth.eval("swap")
+      Forth.new() |> Forth.eval("swap")
     end
   end
 
   @tag :pending
   test "over" do
-    s = Forth.new
-        |> Forth.eval("1 2 over")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 over")
+      |> Forth.format_stack()
+
     assert s == "1 2 1"
-    s = Forth.new
-        |> Forth.eval("1 2 3 over")
-        |> Forth.format_stack
+
+    s =
+      Forth.new()
+      |> Forth.eval("1 2 3 over")
+      |> Forth.format_stack()
+
     assert s == "1 2 3 2"
+
     assert_raise Forth.StackUnderflow, fn ->
-      Forth.new |> Forth.eval("1 over")
+      Forth.new() |> Forth.eval("1 over")
     end
+
     assert_raise Forth.StackUnderflow, fn ->
-      Forth.new |> Forth.eval("over")
+      Forth.new() |> Forth.eval("over")
     end
   end
 
   @tag :pending
   test "defining a new word" do
-    s = Forth.new
-        |> Forth.eval(": dup-twice dup dup ;")
-        |> Forth.eval("1 dup-twice")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval(": dup-twice dup dup ;")
+      |> Forth.eval("1 dup-twice")
+      |> Forth.format_stack()
+
     assert s == "1 1 1"
   end
 
   @tag :pending
   test "redefining an existing word" do
-    s = Forth.new
-        |> Forth.eval(": foo dup ;")
-        |> Forth.eval(": foo dup dup ;")
-        |> Forth.eval("1 foo")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval(": foo dup ;")
+      |> Forth.eval(": foo dup dup ;")
+      |> Forth.eval("1 foo")
+      |> Forth.format_stack()
+
     assert s == "1 1 1"
   end
 
   @tag :pending
   test "redefining an existing built-in word" do
-    s = Forth.new
-        |> Forth.eval(": swap dup ;")
-        |> Forth.eval("1 swap")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval(": swap dup ;")
+      |> Forth.eval("1 swap")
+      |> Forth.format_stack()
+
     assert s == "1 1"
   end
 
   @tag :pending
   test "defining words with odd characters" do
-    s = Forth.new
-        |> Forth.eval(": € 220371 ; €")
-        |> Forth.format_stack
+    s =
+      Forth.new()
+      |> Forth.eval(": € 220371 ; €")
+      |> Forth.format_stack()
+
     assert s == "220371"
   end
 
   @tag :pending
   test "defining a number" do
     assert_raise Forth.InvalidWord, fn ->
-      Forth.new |> Forth.eval(": 1 2 ;")
+      Forth.new() |> Forth.eval(": 1 2 ;")
     end
   end
 
   @tag :pending
   test "calling a non-existing word" do
     assert_raise Forth.UnknownWord, fn ->
-      Forth.new |> Forth.eval("1 foo")
+      Forth.new() |> Forth.eval("1 foo")
     end
   end
 end