trackler 2.2.1.109 → 2.2.1.110

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

@@ -1,6 +1,6 @@
 defmodule Gigasecond do
   def from(time) do
     seconds = :calendar.datetime_to_gregorian_seconds(time)
-    :calendar.gregorian_seconds_to_datetime(seconds + 1000000000)
+    :calendar.gregorian_seconds_to_datetime(seconds + 1_000_000_000)
   end
 end

data/tracks/elixir/exercises/gigasecond/gigasecond.exs

@@ -2,9 +2,9 @@ defmodule Gigasecond do
   @doc """
   Calculate a date one billion seconds after an input date.
   """
-  @spec from({{pos_integer, pos_integer, pos_integer}, {pos_integer, pos_integer, pos_integer}}) :: :calendar.datetime
+  @spec from({{pos_integer, pos_integer, pos_integer}, {pos_integer, pos_integer, pos_integer}}) ::
+          :calendar.datetime()
 
   def from({{year, month, day}, {hours, minutes, seconds}}) do
-
   end
 end

data/tracks/elixir/exercises/gigasecond/gigasecond_test.exs

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

data/tracks/elixir/exercises/grade-school/example.exs

@@ -1,6 +1,6 @@
 defmodule School do
   def add(db, name, grade) do
-    Map.update(db, grade, [name], &[name|&1])
+    Map.update(db, grade, [name], &[name | &1])
   end
 
   def grade(db, grade) do
@@ -9,7 +9,7 @@ defmodule School do
 
   def sort(db) do
     db
-    |> Enum.map(fn {k,v} -> {k, Enum.sort(v)} end)
-    |> Enum.sort
+    |> Enum.map(fn {k, v} -> {k, Enum.sort(v)} end)
+    |> Enum.sort()
   end
 end

data/tracks/elixir/exercises/grade-school/grade_school_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("school.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule SchoolTest do
   use ExUnit.Case
@@ -12,35 +12,38 @@ defmodule SchoolTest do
 
   test "add student" do
     actual = School.add(@db, "Aimee", 2)
-    assert actual == %{2 =>["Aimee"]}
+    assert actual == %{2 => ["Aimee"]}
   end
 
   @tag :pending
   test "add more students in same class" do
-    actual = @db
-    |> School.add("James", 2)
-    |> School.add("Blair", 2)
-    |> School.add("Paul", 2)
+    actual =
+      @db
+      |> School.add("James", 2)
+      |> School.add("Blair", 2)
+      |> School.add("Paul", 2)
 
     assert Enum.sort(actual[2]) == ["Blair", "James", "Paul"]
   end
 
   @tag :pending
   test "add students to different grades" do
-    actual = @db
-    |> School.add("Chelsea", 3)
-    |> School.add("Logan", 7)
+    actual =
+      @db
+      |> School.add("Chelsea", 3)
+      |> School.add("Logan", 7)
 
     assert actual == %{3 => ["Chelsea"], 7 => ["Logan"]}
   end
 
   @tag :pending
   test "get students in a grade" do
-    actual = @db
-    |> School.add("Bradley", 5)
-    |> School.add("Franklin", 5)
-    |> School.add("Jeff", 1)
-    |> School.grade(5)
+    actual =
+      @db
+      |> School.add("Bradley", 5)
+      |> School.add("Franklin", 5)
+      |> School.add("Jeff", 1)
+      |> School.grade(5)
 
     assert Enum.sort(actual) == ["Bradley", "Franklin"]
   end
@@ -52,13 +55,14 @@ defmodule SchoolTest do
 
   @tag :pending
   test "sort school by grade and by student name" do
-    actual = @db
-    |> School.add("Bart", 4)
-    |> School.add("Jennifer", 4)
-    |> School.add("Christopher", 4)
-    |> School.add("Kareem", 6)
-    |> School.add("Kyle", 3)
-    |> School.sort
+    actual =
+      @db
+      |> School.add("Bart", 4)
+      |> School.add("Jennifer", 4)
+      |> School.add("Christopher", 4)
+      |> School.add("Kareem", 6)
+      |> School.add("Kyle", 3)
+      |> School.sort()
 
     expected = [
       {3, ["Kyle"]},

data/tracks/elixir/exercises/grade-school/school.exs

@@ -8,24 +8,21 @@ defmodule School do
   @doc """
   Add a student to a particular grade in school.
   """
-  @spec add(map, String.t, integer) :: map
+  @spec add(map, String.t(), integer) :: map
   def add(db, name, grade) do
-
   end
 
   @doc """
   Return the names of the students in a particular grade.
   """
-  @spec grade(map, integer) :: [String.t]
+  @spec grade(map, integer) :: [String.t()]
   def grade(db, grade) do
-
   end
 
   @doc """
   Sorts the school by grade and name.
   """
-  @spec sort(map) :: [{integer, [String.t]}]
+  @spec sort(map) :: [{integer, [String.t()]}]
   def sort(db) do
-
   end
 end

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

@@ -1,6 +1,13 @@
 defmodule Grains do
   use Bitwise, only_operators: true
-  def square(number) when number in (1..64), do: { :ok, 1 <<< (number - 1) }
-  def square(_), do: { :error, "The requested square must be between 1 and 64 (inclusive)" }
-  def total, do: { :ok, Enum.reduce(1..64, 0, fn(n, acc) -> {:ok, sq} = square(n); acc + sq end) }
+  def square(number) when number in 1..64, do: {:ok, 1 <<< (number - 1)}
+  def square(_), do: {:error, "The requested square must be between 1 and 64 (inclusive)"}
+
+  def total,
+    do:
+      {:ok,
+       Enum.reduce(1..64, 0, fn n, acc ->
+         {:ok, sq} = square(n)
+         acc + sq
+       end)}
 end

data/tracks/elixir/exercises/grains/grains.exs

@@ -4,7 +4,6 @@ defmodule Grains do
   """
   @spec square(pos_integer) :: pos_integer
   def square(number) do
-
   end
 
   @doc """
@@ -12,6 +11,5 @@ defmodule Grains do
   """
   @spec total :: pos_integer
   def total do
-
   end
 end

data/tracks/elixir/exercises/grains/grains_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("grains.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 # NOTE: :math.pow/2 doesn't do what you'd expect:
 # `:math.pow(2, 64) == :math.pow(2, 64) - 1` is true.
@@ -16,57 +16,59 @@ defmodule GrainsTest do
 
   # @tag :pending
   test "square 1" do
-    assert Grains.square(1) === { :ok, 1 }
+    assert Grains.square(1) === {:ok, 1}
   end
 
   @tag :pending
   test "square 2" do
-    assert Grains.square(2) === { :ok, 2 }
+    assert Grains.square(2) === {:ok, 2}
   end
 
   @tag :pending
   test "square 3" do
-    assert Grains.square(3) === { :ok, 4 }
+    assert Grains.square(3) === {:ok, 4}
   end
 
   @tag :pending
   test "square 4" do
-    assert Grains.square(4) === { :ok, 8 }
+    assert Grains.square(4) === {:ok, 8}
   end
 
   @tag :pending
   test "square 16" do
-    assert Grains.square(16) === { :ok, 32768 }
+    assert Grains.square(16) === {:ok, 32768}
   end
 
   @tag :pending
   test "square 32" do
-    assert Grains.square(32) === { :ok, 2147483648 }
+    assert Grains.square(32) === {:ok, 2_147_483_648}
   end
 
   @tag :pending
   test "square 64" do
-    assert Grains.square(64) === { :ok, 9223372036854775808 }
+    assert Grains.square(64) === {:ok, 9_223_372_036_854_775_808}
   end
 
   @tag :pending
   test "total grains" do
-    assert Grains.total === { :ok, 18446744073709551615 }
+    assert Grains.total() === {:ok, 18_446_744_073_709_551_615}
   end
 
   @tag :pending
   test "square greater than 64 returns an error" do
-    assert Grains.square(65) === { :error, "The requested square must be between 1 and 64 (inclusive)" }
+    assert Grains.square(65) ===
+             {:error, "The requested square must be between 1 and 64 (inclusive)"}
   end
 
   @tag :pending
   test "negative square returns an error" do
-    assert Grains.square(-1) === { :error, "The requested square must be between 1 and 64 (inclusive)" }
+    assert Grains.square(-1) ===
+             {:error, "The requested square must be between 1 and 64 (inclusive)"}
   end
 
   @tag :pending
   test "square 0 returns an error" do
-    assert Grains.square(0) === { :error, "The requested square must be between 1 and 64 (inclusive)" }
+    assert Grains.square(0) ===
+             {:error, "The requested square must be between 1 and 64 (inclusive)"}
   end
-
 end

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

@@ -17,22 +17,25 @@ defmodule Grep do
   defp parse_flags(flags) do
     flags
     |> Enum.map(&parse_flag/1)
-    |> Enum.reduce(0, fn(a,b) -> a ||| b end)
+    |> Enum.reduce(0, fn a, b -> a ||| b end)
   end
 
   defp has_flag(flags, flag), do: (flags &&& flag) > 0
 
   defp is_match(pattern, flags) do
-    pat = if has_flag(flags, @entire_lines) do
-      "^#{pattern}$"
-    else
-      pattern
-    end
-    cas = if has_flag(flags, @case_insensitive) do
-      "i"
-    else
-      ""
-    end
+    pat =
+      if has_flag(flags, @entire_lines) do
+        "^#{pattern}$"
+      else
+        pattern
+      end
+
+    cas =
+      if has_flag(flags, @case_insensitive) do
+        "i"
+      else
+        ""
+      end
 
     regex = Regex.compile!(pat, cas)
 
@@ -75,18 +78,19 @@ defmodule Grep do
     |> Enum.map(fmt)
   end
 
-  @spec grep(String.t, [String.t], [String.t]) :: String.t
+  @spec grep(String.t(), [String.t()], [String.t()]) :: String.t()
   def grep(pattern, flag_args, files) do
     flags = parse_flags(flag_args)
 
-    output = if has_flag(flags, @file_name) do
-      process_files(pattern, flags, files)
-    else
-      process_lines(pattern, flags, files)
-    end
+    output =
+      if has_flag(flags, @file_name) do
+        process_files(pattern, flags, files)
+      else
+        process_lines(pattern, flags, files)
+      end
 
     output
     |> Enum.map(fn l -> "#{l}\n" end)
-    |> Enum.reduce("", fn b,a -> "#{a}#{b}" end)
+    |> Enum.reduce("", fn b, a -> "#{a}#{b}" end)
   end
 end

data/tracks/elixir/exercises/grep/grep.exs

@@ -1,6 +1,5 @@
 defmodule Grep do
-
-  @spec grep(String.t, [String.t], [String.t]) :: String.t
+  @spec grep(String.t(), [String.t()], [String.t()]) :: String.t()
   def grep(pattern, flags, files) do
   end
 end

data/tracks/elixir/exercises/grep/grep_test.exs

@@ -2,14 +2,13 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("grep.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule GrepTest do
   use ExUnit.Case
 
   setup context do
-
     if context[:files] do
       File.write!("iliad.txt", """
       Achilles sing, O Goddess! Peleus' son;
@@ -31,8 +30,7 @@ defmodule GrepTest do
       But I beseech your grace that I may know
       The worst that may befall me in this case,
       If I refuse to wed Demetrius.
-      """
-      )
+      """)
 
       File.write!("paradise-lost.txt", """
       Of Mans First Disobedience, and the Fruit
@@ -45,85 +43,82 @@ defmodule GrepTest do
       That Shepherd, who first taught the chosen Seed
       """)
 
-      on_exit fn ->
+      on_exit(fn ->
         File.rm!("iliad.txt")
         File.rm!("midsummer-night.txt")
         File.rm!("paradise-lost.txt")
-      end
+      end)
     end
   end
 
   @moduletag :files
 
   describe "grepping a single file" do
-
     test "one match, no flags" do
       assert Grep.grep("Agamemnon", [], ["iliad.txt"]) ==
-        """
-        Of Atreus, Agamemnon, King of men.
-        """
+               """
+               Of Atreus, Agamemnon, King of men.
+               """
     end
 
     @tag :pending
     test "one match, print line numbers flag" do
       assert Grep.grep("Forbidden", ["-n"], ["paradise-lost.txt"]) ==
-        """
-        2:Of that Forbidden Tree, whose mortal tast
-        """
+               """
+               2:Of that Forbidden Tree, whose mortal tast
+               """
     end
 
     @tag :pending
     test "one match, case-insensitive flag" do
       assert Grep.grep("FORBIDDEN", ["-i"], ["paradise-lost.txt"]) ==
-        """
-        Of that Forbidden Tree, whose mortal tast
-        """
+               """
+               Of that Forbidden Tree, whose mortal tast
+               """
     end
 
     @tag :pending
     test "one match, print file names flag" do
       assert Grep.grep("Forbidden", ["-l"], ["paradise-lost.txt"]) ==
-        """
-        paradise-lost.txt
-        """
+               """
+               paradise-lost.txt
+               """
     end
 
     @tag :pending
     test "one match, match entire lines flag" do
-      assert Grep.grep("With loss of Eden, till one greater Man",
-                       ["-x"], ["paradise-lost.txt"]) ==
-        """
-        With loss of Eden, till one greater Man
-        """
+      assert Grep.grep("With loss of Eden, till one greater Man", ["-x"], ["paradise-lost.txt"]) ==
+               """
+               With loss of Eden, till one greater Man
+               """
     end
 
     @tag :pending
     test "one match, multiple flags" do
-      assert Grep.grep("OF ATREUS, Agamemnon, KIng of MEN.",
-                       ["-n", "-i", "-x"], ["iliad.txt"]) ==
-        """
-        9:Of Atreus, Agamemnon, King of men.
-        """
+      assert Grep.grep("OF ATREUS, Agamemnon, KIng of MEN.", ["-n", "-i", "-x"], ["iliad.txt"]) ==
+               """
+               9:Of Atreus, Agamemnon, King of men.
+               """
     end
 
     @tag :pending
     test "several matches, no flags" do
       assert Grep.grep("may", [], ["midsummer-night.txt"]) ==
-        """
-        Nor how it may concern my modesty,
-        But I beseech your grace that I may know
-        The worst that may befall me in this case,
-        """
+               """
+               Nor how it may concern my modesty,
+               But I beseech your grace that I may know
+               The worst that may befall me in this case,
+               """
     end
 
     @tag :pending
     test "several matches, print line numbers flag" do
       assert Grep.grep("may", ["-n"], ["midsummer-night.txt"]) ==
-        """
-        3:Nor how it may concern my modesty,
-        5:But I beseech your grace that I may know
-        6:The worst that may befall me in this case,
-        """
+               """
+               3:Nor how it may concern my modesty,
+               5:But I beseech your grace that I may know
+               6:The worst that may befall me in this case,
+               """
     end
 
     @tag :pending
@@ -134,22 +129,22 @@ defmodule GrepTest do
     @tag :pending
     test "several matches, case-insensitive flag" do
       assert Grep.grep("ACHILLES", ["-i"], ["iliad.txt"]) ==
-        """
-        Achilles sing, O Goddess! Peleus' son;
-        The noble Chief Achilles from the son
-        """
+               """
+               Achilles sing, O Goddess! Peleus' son;
+               The noble Chief Achilles from the son
+               """
     end
 
     @tag :pending
     test "several matches, inverted flag" do
       assert Grep.grep("Of", ["-v"], ["paradise-lost.txt"]) ==
-        """
-        Brought Death into the World, and all our woe,
-        With loss of Eden, till one greater Man
-        Restore us, and regain the blissful Seat,
-        Sing Heav'nly Muse, that on the secret top
-        That Shepherd, who first taught the chosen Seed
-        """
+               """
+               Brought Death into the World, and all our woe,
+               With loss of Eden, till one greater Man
+               Restore us, and regain the blissful Seat,
+               Sing Heav'nly Muse, that on the secret top
+               That Shepherd, who first taught the chosen Seed
+               """
     end
 
     @tag :pending
@@ -159,101 +154,102 @@ defmodule GrepTest do
   end
 
   describe "grepping multiples files at once" do
-
     @tag :pending
     test "one match, no flags" do
-      assert Grep.grep("Agamemnon", [],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        iliad.txt:Of Atreus, Agamemnon, King of men.
-        """
+      assert Grep.grep("Agamemnon", [], ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
+               """
+               iliad.txt:Of Atreus, Agamemnon, King of men.
+               """
     end
 
     @tag :pending
     test "several matches, no flags" do
-      assert Grep.grep("may", [],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        midsummer-night.txt:Nor how it may concern my modesty,
-        midsummer-night.txt:But I beseech your grace that I may know
-        midsummer-night.txt:The worst that may befall me in this case,
-        """
+      assert Grep.grep("may", [], ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
+               """
+               midsummer-night.txt:Nor how it may concern my modesty,
+               midsummer-night.txt:But I beseech your grace that I may know
+               midsummer-night.txt:The worst that may befall me in this case,
+               """
     end
 
     @tag :pending
     test "several matches, print line numbers flag" do
-      assert Grep.grep("that", ["-n"],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        midsummer-night.txt:5:But I beseech your grace that I may know
-        midsummer-night.txt:6:The worst that may befall me in this case,
-        paradise-lost.txt:2:Of that Forbidden Tree, whose mortal tast
-        paradise-lost.txt:6:Sing Heav'nly Muse, that on the secret top
-        """
+      assert Grep.grep("that", ["-n"], ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
+               """
+               midsummer-night.txt:5:But I beseech your grace that I may know
+               midsummer-night.txt:6:The worst that may befall me in this case,
+               paradise-lost.txt:2:Of that Forbidden Tree, whose mortal tast
+               paradise-lost.txt:6:Sing Heav'nly Muse, that on the secret top
+               """
     end
 
     @tag :pending
     test "one match, print file names flag" do
-      assert Grep.grep("who", ["-l"],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        iliad.txt
-        paradise-lost.txt
-        """
+      assert Grep.grep("who", ["-l"], ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
+               """
+               iliad.txt
+               paradise-lost.txt
+               """
     end
 
     @tag :pending
     test "several matches, case-insensitive flag" do
-      assert Grep.grep("TO", ["-i"],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        iliad.txt:Caused to Achaia's host, sent many a soul
-        iliad.txt:Illustrious into Ades premature,
-        iliad.txt:And Heroes gave (so stood the will of Jove)
-        iliad.txt:To dogs and to all ravening fowls a prey,
-        midsummer-night.txt:I do entreat your grace to pardon me.
-        midsummer-night.txt:In such a presence here to plead my thoughts;
-        midsummer-night.txt:If I refuse to wed Demetrius.
-        paradise-lost.txt:Brought Death into the World, and all our woe,
-        paradise-lost.txt:Restore us, and regain the blissful Seat,
-        paradise-lost.txt:Sing Heav'nly Muse, that on the secret top
-        """
+      assert Grep.grep("TO", ["-i"], ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
+               """
+               iliad.txt:Caused to Achaia's host, sent many a soul
+               iliad.txt:Illustrious into Ades premature,
+               iliad.txt:And Heroes gave (so stood the will of Jove)
+               iliad.txt:To dogs and to all ravening fowls a prey,
+               midsummer-night.txt:I do entreat your grace to pardon me.
+               midsummer-night.txt:In such a presence here to plead my thoughts;
+               midsummer-night.txt:If I refuse to wed Demetrius.
+               paradise-lost.txt:Brought Death into the World, and all our woe,
+               paradise-lost.txt:Restore us, and regain the blissful Seat,
+               paradise-lost.txt:Sing Heav'nly Muse, that on the secret top
+               """
     end
 
     @tag :pending
     test "several matches, inverted flag" do
-      assert Grep.grep("a", ["-v"],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        iliad.txt:Achilles sing, O Goddess! Peleus' son;
-        iliad.txt:The noble Chief Achilles from the son
-        midsummer-night.txt:If I refuse to wed Demetrius.
-        """
+      assert Grep.grep("a", ["-v"], ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
+               """
+               iliad.txt:Achilles sing, O Goddess! Peleus' son;
+               iliad.txt:The noble Chief Achilles from the son
+               midsummer-night.txt:If I refuse to wed Demetrius.
+               """
     end
 
     @tag :pending
     test "one match, match entire lines flag" do
-      assert Grep.grep("But I beseech your grace that I may know", ["-x"],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        midsummer-night.txt:But I beseech your grace that I may know
-        """
+      assert Grep.grep("But I beseech your grace that I may know", ["-x"], [
+               "iliad.txt",
+               "midsummer-night.txt",
+               "paradise-lost.txt"
+             ]) ==
+               """
+               midsummer-night.txt:But I beseech your grace that I may know
+               """
     end
 
     @tag :pending
     test "one match, multiple flags" do
-      assert Grep.grep("WITH LOSS OF EDEN, TILL ONE GREATER MAN",
-        ["-n", "-x", "-i"],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) ==
-        """
-        paradise-lost.txt:4:With loss of Eden, till one greater Man
-        """
+      assert Grep.grep("WITH LOSS OF EDEN, TILL ONE GREATER MAN", ["-n", "-x", "-i"], [
+               "iliad.txt",
+               "midsummer-night.txt",
+               "paradise-lost.txt"
+             ]) ==
+               """
+               paradise-lost.txt:4:With loss of Eden, till one greater Man
+               """
     end
 
     @tag :pending
     test "no matches, various flags" do
-      assert Grep.grep("Frodo", ["-n", "-l", "-x", "i"],
-        ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]) == ""
+      assert Grep.grep("Frodo", ["-n", "-l", "-x", "i"], [
+               "iliad.txt",
+               "midsummer-night.txt",
+               "paradise-lost.txt"
+             ]) == ""
     end
   end
 end