trackler 2.2.1.109 → 2.2.1.110

data/tracks/elixir/exercises/scrabble-score/scrabble.exs

@@ -2,8 +2,7 @@ defmodule Scrabble do
   @doc """
   Calculate the scrabble score for the word.
   """
-  @spec score(String.t) :: non_neg_integer
+  @spec score(String.t()) :: non_neg_integer
   def score(word) do
-
   end
 end

data/tracks/elixir/exercises/scrabble-score/scrabble_score_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("scrabble.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule ScrabbleScoreTest do
   use ExUnit.Case

data/tracks/elixir/exercises/secret-handshake/example.exs

@@ -20,8 +20,8 @@ defmodule SecretHandshake do
   @spec commands(code :: integer) :: list(String.t())
   def commands(code) do
     @codes
-    |> Enum.with_index
-    |> Enum.map(fn {command, i} -> { command, 2 <<< (i-1) } end)
+    |> Enum.with_index()
+    |> Enum.map(fn {command, i} -> {command, 2 <<< (i - 1)} end)
     |> decode_commands(code, [])
   end
 
@@ -31,7 +31,8 @@ defmodule SecretHandshake do
       _ -> Enum.reverse(results)
     end
   end
-  defp decode_commands([{ command, flag } | flags], code, results) do
+
+  defp decode_commands([{command, flag} | flags], code, results) do
     case flag_set(code, flag) do
       true -> decode_commands(flags, code, [command | results])
       _ -> decode_commands(flags, code, results)
@@ -40,4 +41,3 @@ defmodule SecretHandshake do
 
   defp flag_set(flags, flag_to_check), do: (flags &&& flag_to_check) == flag_to_check
 end
-

data/tracks/elixir/exercises/secret-handshake/secret_handshake.exs

@@ -17,4 +17,3 @@ defmodule SecretHandshake do
   def commands(code) do
   end
 end
-

data/tracks/elixir/exercises/secret-handshake/secret_handshake_test.exs

@@ -2,14 +2,14 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("secret_handshake.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure trace: true, exclude: :pending
+ExUnit.start()
+ExUnit.configure(trace: true, exclude: :pending)
 
 defmodule SecretHandshakeTest do
   use ExUnit.Case
 
   describe "Create a handshake for a number" do
-    #@tag :pending
+    # @tag :pending
     test "wink for 1" do
       assert SecretHandshake.commands(1) == ["wink"]
     end

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

@@ -6,8 +6,8 @@ defmodule StringSeries do
   """
   @spec slices(s :: String.t(), size :: integer) :: list(String.t())
   def slices(_s, size) when size < 1, do: []
+
   def slices(s, size) do
-    s |> String.graphemes |> Enum.chunk(size, 1) |> Enum.map(&Enum.join/1)
+    s |> String.graphemes() |> Enum.chunk(size, 1) |> Enum.map(&Enum.join/1)
   end
 end
-

data/tracks/elixir/exercises/series/series.exs

@@ -8,4 +8,3 @@ defmodule StringSeries do
   def slices(_s, _size) do
   end
 end
-

data/tracks/elixir/exercises/series/series_test.exs

@@ -2,13 +2,13 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("series.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule StringSeriesTest do
   use ExUnit.Case
 
-  #@tag :pending
+  # @tag :pending
   test "slices of size 1" do
     assert StringSeries.slices("01234", 1) == ["0", "1", "2", "3", "4"]
   end
@@ -50,4 +50,3 @@ defmodule StringSeriesTest do
     assert StringSeries.slices("01234", 0) == []
   end
 end
-

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

@@ -1,17 +1,16 @@
 defmodule Sieve do
-
   @doc """
   Generates a list of primes up to a given limit.
   """
   @spec primes_to(non_neg_integer) :: [non_neg_integer]
   def primes_to(limit) do
-    Enum.to_list(2..limit) |> do_primes([]) |> Enum.reverse
+    Enum.to_list(2..limit) |> do_primes([]) |> Enum.reverse()
   end
 
   defp do_primes([], primes), do: primes
-  defp do_primes([ candidate | rest ], primes) do
+
+  defp do_primes([candidate | rest], primes) do
     candidates = Enum.reject(rest, &(rem(&1, candidate) == 0))
-    do_primes(candidates, [ candidate | primes ])
+    do_primes(candidates, [candidate | primes])
   end
-
 end

data/tracks/elixir/exercises/sieve/sieve.exs

@@ -1,11 +1,8 @@
 defmodule Sieve do
-
   @doc """
   Generates a list of primes up to a given limit.
   """
   @spec primes_to(non_neg_integer) :: [non_neg_integer]
   def primes_to(limit) do
-
   end
-
 end

data/tracks/elixir/exercises/sieve/sieve_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("sieve.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule SieveTest do
   use ExUnit.Case
@@ -15,25 +15,177 @@ defmodule SieveTest do
 
   @tag :pending
   test "primes to 1000" do
-    result = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
-    41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
-    89, 97, 101, 103, 107, 109, 113, 127, 131,
-    137, 139, 149, 151, 157, 163, 167, 173, 179,
-    181, 191, 193, 197, 199, 211, 223, 227, 229,
-    233, 239, 241, 251, 257, 263, 269, 271, 277,
-    281, 283, 293, 307, 311, 313, 317, 331, 337,
-    347, 349, 353, 359, 367, 373, 379, 383, 389,
-    397, 401, 409, 419, 421, 431, 433, 439, 443,
-    449, 457, 461, 463, 467, 479, 487, 491, 499,
-    503, 509, 521, 523, 541, 547, 557, 563, 569,
-    571, 577, 587, 593, 599, 601, 607, 613, 617,
-    619, 631, 641, 643, 647, 653, 659, 661, 673,
-    677, 683, 691, 701, 709, 719, 727, 733, 739,
-    743, 751, 757, 761, 769, 773, 787, 797, 809,
-    811, 821, 823, 827, 829, 839, 853, 857, 859,
-    863, 877, 881, 883, 887, 907, 911, 919, 929,
-    937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
+    result = [
+      2,
+      3,
+      5,
+      7,
+      11,
+      13,
+      17,
+      19,
+      23,
+      29,
+      31,
+      37,
+      41,
+      43,
+      47,
+      53,
+      59,
+      61,
+      67,
+      71,
+      73,
+      79,
+      83,
+      89,
+      97,
+      101,
+      103,
+      107,
+      109,
+      113,
+      127,
+      131,
+      137,
+      139,
+      149,
+      151,
+      157,
+      163,
+      167,
+      173,
+      179,
+      181,
+      191,
+      193,
+      197,
+      199,
+      211,
+      223,
+      227,
+      229,
+      233,
+      239,
+      241,
+      251,
+      257,
+      263,
+      269,
+      271,
+      277,
+      281,
+      283,
+      293,
+      307,
+      311,
+      313,
+      317,
+      331,
+      337,
+      347,
+      349,
+      353,
+      359,
+      367,
+      373,
+      379,
+      383,
+      389,
+      397,
+      401,
+      409,
+      419,
+      421,
+      431,
+      433,
+      439,
+      443,
+      449,
+      457,
+      461,
+      463,
+      467,
+      479,
+      487,
+      491,
+      499,
+      503,
+      509,
+      521,
+      523,
+      541,
+      547,
+      557,
+      563,
+      569,
+      571,
+      577,
+      587,
+      593,
+      599,
+      601,
+      607,
+      613,
+      617,
+      619,
+      631,
+      641,
+      643,
+      647,
+      653,
+      659,
+      661,
+      673,
+      677,
+      683,
+      691,
+      701,
+      709,
+      719,
+      727,
+      733,
+      739,
+      743,
+      751,
+      757,
+      761,
+      769,
+      773,
+      787,
+      797,
+      809,
+      811,
+      821,
+      823,
+      827,
+      829,
+      839,
+      853,
+      857,
+      859,
+      863,
+      877,
+      881,
+      883,
+      887,
+      907,
+      911,
+      919,
+      929,
+      937,
+      941,
+      947,
+      953,
+      967,
+      971,
+      977,
+      983,
+      991,
+      997
+    ]
+
     assert Sieve.primes_to(1000) == result
   end
-
 end

data/tracks/elixir/exercises/simple-cipher/example.exs

@@ -1,13 +1,14 @@
 defmodule SimpleCipher do
-  @alphabet "abcdefghijklmnopqrstuvwxyz" |> String.graphemes
+  @alphabet "abcdefghijklmnopqrstuvwxyz" |> String.graphemes()
   @alphabet_size @alphabet |> length
 
   for key_char <- @alphabet do
-    shifted_alphabet = Stream.cycle(@alphabet)
-                       |> Stream.drop_while(&(&1 != key_char))
-                       |> Enum.take(@alphabet_size)
+    shifted_alphabet =
+      Stream.cycle(@alphabet)
+      |> Stream.drop_while(&(&1 != key_char))
+      |> Enum.take(@alphabet_size)
 
-    for { plain, cipher } <- Enum.zip(@alphabet, shifted_alphabet) do
+    for {plain, cipher} <- Enum.zip(@alphabet, shifted_alphabet) do
       defp encode_char(unquote(plain), unquote(key_char)), do: unquote(cipher)
       defp decode_char(unquote(cipher), unquote(key_char)), do: unquote(plain)
     end
@@ -69,12 +70,11 @@ defmodule SimpleCipher do
   end
 
   defp convert_keystream(text, key, converter) do
-    keystream = key |> String.graphemes |> Stream.cycle
+    keystream = key |> String.graphemes() |> Stream.cycle()
 
     text
-    |> String.graphemes
+    |> String.graphemes()
     |> Enum.zip(keystream)
     |> Enum.map_join(converter)
   end
 end
-

data/tracks/elixir/exercises/simple-cipher/simple_cipher.exs

@@ -46,4 +46,3 @@ defmodule SimpleCipher do
   def decode(ciphertext, key) do
   end
 end
-

data/tracks/elixir/exercises/simple-cipher/simple_cipher_test.exs

@@ -2,13 +2,13 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("simple_cipher.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure trace: true, exclude: :pending
+ExUnit.start()
+ExUnit.configure(trace: true, exclude: :pending)
 
 defmodule SimpleCipherTest do
   use ExUnit.Case
 
-  #@tag :pending
+  # @tag :pending
   test "encoding with 'a' returns the original text" do
     assert SimpleCipher.encode("a", "a") == "a"
     assert SimpleCipher.encode("b", "a") == "b"
@@ -86,4 +86,3 @@ defmodule SimpleCipherTest do
     assert SimpleCipher.decode(ciphertext, plaintext) == key
   end
 end
-

data/tracks/elixir/exercises/simple-linked-list/example.exs

@@ -71,8 +71,9 @@ defmodule LinkedList do
   def to_list(list) do
     list |> do_to_list([]) |> Enum.reverse()
   end
+
   defp do_to_list({}, acc), do: acc
-  defp do_to_list({h, t}, acc), do: do_to_list(t, [h|acc])
+  defp do_to_list({h, t}, acc), do: do_to_list(t, [h | acc])
 
   @doc """
   Reverse a LinkedList
@@ -81,6 +82,7 @@ defmodule LinkedList do
   def reverse(list) do
     do_reverse(list, new())
   end
+
   def do_reverse({}, acc), do: acc
   def do_reverse({h, t}, acc), do: do_reverse(t, push(acc, h))
 end

data/tracks/elixir/exercises/simple-linked-list/linked_list_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("linked_list.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule LinkedListTest do
   use ExUnit.Case
@@ -62,6 +62,7 @@ defmodule LinkedListTest do
       LinkedList.new()
       |> LinkedList.push(:a)
       |> LinkedList.push(:b)
+
     assert LinkedList.peek(list) == {:ok, :b}
     assert {:ok, list} = LinkedList.tail(list)
     assert LinkedList.peek(list) == {:ok, :a}
@@ -145,10 +146,12 @@ defmodule LinkedListTest do
   @tag :pending
   test "reverse/1 round trip" do
     list = Enum.to_list(1..200)
+
     linked_list =
       LinkedList.from_list(list)
       |> LinkedList.reverse()
       |> LinkedList.reverse()
+
     assert LinkedList.to_list(linked_list) == list
   end
 end