trackler 2.2.1.47 → 2.2.1.48

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

@@ -2,43 +2,56 @@ defmodule Minesweeper do
   @doc """
   Annotate empty spots next to mines with the number of mines next to them.
   """
-  @spec annotate([String.t]) :: [String.t]
+  @spec annotate([String.t()]) :: [String.t()]
   def annotate([]), do: []
+
   def annotate(board) do
     h = length(board)
-    w = String.length(hd(board)) # Only 7-bit ASCII in the board, so this is safe
+    # Only 7-bit ASCII in the board, so this is safe
+    w = String.length(hd(board))
+
     annotations =
-      Enum.reduce(Stream.with_index(board), %{}, fn { line, y }, acc ->
-        Enum.reduce(Stream.with_index(String.to_char_list(line)), acc, fn
-          { ?*, x }, acc -> add_adjacents(acc, { x, y }, { w, h })
-          _, acc         -> acc
+      Enum.reduce(Stream.with_index(board), %{}, fn {line, y}, acc ->
+        Enum.reduce(Stream.with_index(String.to_charlist(line)), acc, fn
+          {?*, x}, acc -> add_adjacents(acc, {x, y}, {w, h})
+          _, acc -> acc
         end)
       end)
-    Enum.map(Stream.with_index(board), fn { line, y } ->
-      Enum.map(Stream.with_index(String.to_char_list(line)), fn
-        { ?*, _ } -> ?* # Don't replace mines
-        { _, x }  -> case annotations[{x, y}] do
-                       nil -> ?\s
-                       n   -> ?0 + n
-                     end
-      end) |> to_string
+
+    Enum.map(Stream.with_index(board), fn {line, y} ->
+      Enum.map(Stream.with_index(String.to_charlist(line)), fn
+        # Don't replace mines
+        {?*, _} ->
+          ?*
+
+        {_, x} ->
+          case annotations[{x, y}] do
+            nil -> ?\s
+            n -> ?0 + n
+          end
+      end)
+      |> to_string
     end)
   end
 
-  @adjacent_vecs for x <- [-1, 0, 1], y <- [-1, 0, 1], x != 0 or y != 0, do: { x, y }
+  @adjacent_vecs for x <- [-1, 0, 1],
+                     y <- [-1, 0, 1],
+                     x != 0 or y != 0,
+                     do: {x, y}
 
   defp add_adjacents(d, c, bounds) do
     Enum.reduce(@adjacent_vecs, d, fn v, acc ->
       c1 = add_vec(c, v)
+
       if valid?(c1, bounds) do
-        Map.update(acc, c1, 1, &(&1+1))
+        Map.update(acc, c1, 1, &(&1 + 1))
       else
         acc
       end
     end)
   end
 
-  defp add_vec({ cx, cy }, { vx, vy }), do: { cx + vx, cy + vy }
+  defp add_vec({cx, cy}, {vx, vy}), do: {cx + vx, cy + vy}
 
-  defp valid?({ cx, cy }, { w, h }), do: cx >= 0 and cx < w and cy >= 0 and cy < h
+  defp valid?({cx, cy}, {w, h}), do: cx >= 0 and cx < w and cy >= 0 and cy < h
 end

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

@@ -12,13 +12,13 @@ defmodule Pangram do
 
   """
 
-  @spec pangram?(String.t) :: boolean
+  @spec pangram?(String.t()) :: boolean
   def pangram?(sentence) do
     chars =
       sentence
-      |> String.downcase
-      |> to_char_list
+      |> String.downcase()
+      |> to_charlist
 
-    Enum.all? ?a..?z, &(&1 in chars)
+    Enum.all?(?a..?z, &(&1 in chars))
   end
 end

data/tracks/elixir/exercises/queen-attack/queen_attack_test.exs

@@ -2,15 +2,15 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("queen_attack.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule QueenAttackTest do
   use ExUnit.Case
 
   # @tag :pending
   test "default positions" do
-    queens = Queens.new
+    queens = Queens.new()
     assert queens.white == {0, 3}
     assert queens.black == {7, 3}
   end
@@ -32,80 +32,95 @@ defmodule QueenAttackTest do
   @tag :pending
   test "string representation" do
     queens = Queens.new({2, 4}, {6, 6})
-    board = String.strip """
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ W _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ B _
-_ _ _ _ _ _ _ _
-    """
+
+    board =
+      String.trim("""
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ W _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ B _
+      _ _ _ _ _ _ _ _
+      """)
+
     assert Queens.to_string(queens) == board
   end
 
   @tag :pending
   test "another string representation" do
     queens = Queens.new({7, 1}, {0, 0})
-    board = String.strip """
-B _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ W _ _ _ _ _ _
-    """
+
+    board =
+      String.trim("""
+      B _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ W _ _ _ _ _ _
+      """)
+
     assert Queens.to_string(queens) == board
   end
 
   @tag :pending
   test "yet another string representation" do
     queens = Queens.new({4, 3}, {3, 4})
-    board = String.strip """
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ B _ _ _
-_ _ _ W _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-    """
+
+    board =
+      String.trim("""
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ B _ _ _
+      _ _ _ W _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      """)
+
     assert Queens.to_string(queens) == board
   end
 
   @tag :pending
   test "queen placed on the bottom right corner" do
     queens = Queens.new({4, 3}, {7, 7})
-    board = String.strip """
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ W _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ B
-    """
+
+    board =
+      String.trim("""
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ W _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ B
+      """)
+
     assert Queens.to_string(queens) == board
   end
 
   @tag :pending
   test "queen placed on the edge of the board" do
     queens = Queens.new({4, 3}, {2, 7})
-    board = String.strip """
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ B
-_ _ _ _ _ _ _ _
-_ _ _ W _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-    """
+
+    board =
+      String.trim("""
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ B
+      _ _ _ _ _ _ _ _
+      _ _ _ W _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      _ _ _ _ _ _ _ _
+      """)
+
     assert Queens.to_string(queens) == board
   end
 

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

@@ -31,50 +31,56 @@ defmodule Say do
   Translate a positive integer into English.
   """
 
-  @spec in_english(Integer.t) :: {atom, String.t}
+  @spec in_english(number) :: {atom, String.t()}
   def in_english(number) when number < 0 or number >= 1_000_000_000_000 do
     {:error, "number is out of range"}
   end
+
   def in_english(0), do: {:ok, "zero"}
+
   def in_english(number) do
-    result = Integer.digits(number)
-    |> padded_chunk(3, 0)
-    |> translate_chunks
-    |> clean_join(" ")
+    result =
+      Integer.digits(number)
+      |> padded_chunk(3, 0)
+      |> translate_chunks
+      |> clean_join(" ")
 
     {:ok, result}
   end
 
-
-  @spec translate_chunks(List.t) :: [String.t]
+  @spec translate_chunks(list) :: [String.t()]
   defp translate_chunks(chunks) do
     translate_chunks(chunks, Enum.count(chunks))
   end
 
-
-  @spec translate_chunks(List.t, Integer.t) :: [String.t]
+  @spec translate_chunks(list, number) :: [String.t()]
   defp translate_chunks([chunk], 1), do: [translate_chunk(chunk)]
+
   defp translate_chunks([[0, 0, 0] | remaining], n) do
     translate_chunks(remaining, n - 1)
   end
-  defp translate_chunks([chunk | remaining], n) do
-    chunk_in_english = [
-      translate_chunk(chunk),
-      Enum.at(@separators, n - 2)
-    ]
-    |> clean_join(" ")
 
-    [ chunk_in_english | translate_chunks(remaining, n - 1) ]
+  defp translate_chunks([chunk | remaining], n) do
+    chunk_in_english =
+      [
+        translate_chunk(chunk),
+        Enum.at(@separators, n - 2)
+      ]
+      |> clean_join(" ")
+
+    [chunk_in_english | translate_chunks(remaining, n - 1)]
   end
 
-
-  @spec translate_chunk([Integer.t]) :: String.t
+  @spec translate_chunk([number]) :: String.t()
   defp translate_chunk([0, 0, 0]), do: ""
   defp translate_chunk([0, 0, ones]), do: ones_in_english(ones)
+
   defp translate_chunk([0, 1, ones]) do
     ones_in_english(ones + 10)
   end
+
   defp translate_chunk([0, tens, 0]), do: tens_in_english(tens)
+
   defp translate_chunk([0, tens, ones]) do
     [
       tens_in_english(tens),
@@ -82,9 +88,11 @@ defmodule Say do
     ]
     |> clean_join("-")
   end
+
   defp translate_chunk([hundreds, 0, 0]) do
     "#{ones_in_english(hundreds)} hundred"
   end
+
   defp translate_chunk([hundreds, tens, ones]) do
     [
       translate_chunk([hundreds, 0, 0]),
@@ -93,31 +101,26 @@ defmodule Say do
     |> clean_join(" ")
   end
 
-
-  @spec ones_in_english(Integer.t) :: String.t
+  @spec ones_in_english(number) :: String.t()
   defp ones_in_english(index), do: Enum.at(@small_numbers, index - 1)
 
-
-  @spec tens_in_english(Integer.t) :: String.t
+  @spec tens_in_english(number) :: String.t()
   defp tens_in_english(index), do: Enum.at(@decades, index - 2)
 
-
-  @spec clean_join([any], String.t) :: String.t
+  @spec clean_join([any], String.t()) :: String.t()
   defp clean_join(collection, separator) do
     collection
     |> reject_blank
     |> Enum.join(separator)
   end
 
-
   @spec reject_blank([any]) :: [any]
   defp reject_blank(col) do
     col
     |> Enum.reject(&(&1 == nil || &1 == ""))
   end
 
-
-  @spec padded_chunk([any], Integer.t, any) :: [any]
+  @spec padded_chunk([any], number, any) :: [any]
   defp padded_chunk(list, chunk_size, pad) do
     pad_size = pad_size(chunk_size, rem(Enum.count(list), chunk_size))
 
@@ -125,14 +128,13 @@ defmodule Say do
     |> Enum.chunk(chunk_size)
   end
 
-
-  @spec pad_size(Integer.t, Integer.t) :: Integer.t
+  @spec pad_size(number, number) :: number
   defp pad_size(_, 0), do: 0
   defp pad_size(total, rem), do: total - rem
 
-
-  @spec pad([any], any, Integer.t) :: [any]
+  @spec pad([any], any, number) :: [any]
   defp pad(list, _, 0), do: list
+
   defp pad(list, pad, count) do
     [pad] ++ pad(list, pad, count - 1)
   end

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

@@ -3,23 +3,24 @@ defmodule Scrabble do
     word |> letters |> summarize
   end
 
-  defp letters(word), do: word |> String.strip |> String.downcase |> String.codepoints
+  defp letters(word), do: word |> String.trim() |> String.downcase() |> String.codepoints()
 
-  defp summarize(letters), do: Enum.reduce(letters, 0, fn(letter, acc) -> acc + letter_score(letter) end)
+  defp summarize(letters),
+    do: Enum.reduce(letters, 0, fn letter, acc -> acc + letter_score(letter) end)
 
   @letter_scores [
-    { "aeilnorstu",  1 },
-    { "dg",          2 },
-    { "bcmp",        3 },
-    { "fhvwy",       4 },
-    { "k",           5 },
-    { "jx",          8 },
-    { "qz",         10 }
+    {"aeilnorstu", 1},
+    {"dg", 2},
+    {"bcmp", 3},
+    {"fhvwy", 4},
+    {"k", 5},
+    {"jx", 8},
+    {"qz", 10}
   ]
 
   defp letter_score(letter) do
-    Enum.find_value @letter_scores, 0, fn({letters, score}) ->
+    Enum.find_value(@letter_scores, 0, fn {letters, score} ->
       String.contains?(letters, letter) && score
-    end
+    end)
   end
 end

data/tracks/elixir/mix.exs

@@ -2,12 +2,15 @@ defmodule ExercismTestRunner.Mixfile do
   use Mix.Project
 
   def project do
-    [app: :tests,
-     version: "0.0.1",
-     elixir: "~> 1.3",
-     deps: deps(),
-     test_paths: ["exercises"],
-     consolidate_protocols: false]
+    [
+      app: :tests,
+      version: "0.0.1",
+      elixir: "~> 1.3",
+      deps: deps(),
+      test_paths: ["exercises"],
+      consolidate_protocols: false,
+      dialyzer: [paths: ["tmp/build"]]
+    ]
   end
 
   def application do
@@ -15,6 +18,6 @@ defmodule ExercismTestRunner.Mixfile do
   end
 
   defp deps do
-    [{:poison, "~> 1.4.0"}]
+    [{:poison, "~> 1.4.0"}, {:dialyxir, "~> 0.5"}]
   end
 end