trackler 1.0.0 → 1.0.0.1

data/tracks/elisp/exercises/word-count/example.el

@@ -0,0 +1,18 @@
+;;; word-count.el --- word-count Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+
+(defun word-count (sentence)
+  (let ((count nil))
+    (dolist (i (split-string (downcase sentence) "[^a-z0-9]" t))
+      (let ((n (assoc i count)))
+        (if n (setcdr n (1+ (cdr n)))
+          (push (cons i 1) count))))
+    count))
+
+
+(provide 'word-count)
+;;; word-count.el ends here

data/tracks/elisp/exercises/word-count/word-count-test.el

@@ -0,0 +1,64 @@
+;;; word-count-test.el --- Tests for word-count (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(load-file "word-count.el")
+
+
+(defun equal-assoc (a b)
+  (equal (sort a #'(lambda (a b) (not (string< (car a) (car b)))))
+         (sort b #'(lambda (a b) (not (string< (car a) (car b)))))))
+
+
+(ert-deftest no-words-test ()
+  (should (equal (word-count "")
+                 nil)))
+
+
+(ert-deftest count-one-word-test ()
+  (should (equal (word-count "word")
+                 '(("word" . 1)))))
+
+
+(ert-deftest count-one-of-each-word-test ()
+  (should (equal (word-count "one of each")
+                 '(("each" . 1) 
+                   ("of" . 1)
+                   ("one" . 1)))))
+
+
+(ert-deftest multiple-occurrences-of-a-word-test ()
+  (should (equal (word-count "one fish two fish red fish blue fish")
+                 '(("blue" . 1) 
+                   ("red" . 1) 
+                   ("two" . 1) 
+                   ("fish" . 4)
+                   ("one" . 1)))))
+
+
+(ert-deftest ignore-punctuation-test ()
+  (should (equal (word-count "car : carpet as java : javascript!!&@$%^&")
+                 '(("javascript" . 1)
+                   ("java" . 1)
+                   ("as" . 1)
+                   ("carpet" . 1)
+                   ("car" . 1)))))
+
+
+(ert-deftest include-numbers-test ()
+  (should (equal (word-count "testing, 1, 2 testing")
+                 '(("2" . 1)
+                   ("1" . 1)
+                   ("testing" . 2)))))
+
+
+(ert-deftest normalize-case-test ()
+  (should (equal (word-count "go Go GO Stop stop")
+                 '(("stop" . 2)
+                   ("go" . 3)))))
+
+
+(provide 'word-count)
+;;; word-count-test.el ends here

data/tracks/elisp/exercises/word-count/word-count.el

@@ -0,0 +1,9 @@
+;;; word-count.el --- word-count Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+
+(provide 'word-count)
+;;; word-count.el ends here

data/tracks/elixir/README.md

@@ -37,7 +37,7 @@ The example solution should be named `example.exs`.
 
 - Use typespecs in the example and template files as described [here](http://elixir-lang.org/getting-started/typespecs-and-behaviours.html).
 
-- Each test file should have code like the following at the top of the file. This allows the tests to be run on CI and configures tests to be skipped with the `:skip` flag.
+- Each test file should have code like the following at the top of the file. This allows the tests to be run on CI and configures tests to be skipped with the `:pending` flag.
 
 ```elixir
 if !System.get_env("EXERCISM_TEST_EXAMPLES") do
@@ -45,13 +45,13 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 ```
 
-- All but the initial test for each exercise should be tagged `:skip`.
+- All but the initial test for each exercise should be tagged `:pending`.
 
 ```elixir
-@tag :skip
+@tag :pending
 test "shouting" do
   assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
 end

data/tracks/elixir/SETUP.md

@@ -14,12 +14,12 @@ $ elixir bob_test.exs
 In the test suites, all but the first test have been skipped.
 
 Once you get a test passing, you can unskip the next one by
-commenting out the relevant `@tag :skip` with a `#` symbol.
+commenting out the relevant `@tag :pending` with a `#` symbol.
 
 For example:
 
 ```elixir
-# @tag :skip
+# @tag :pending
 test "shouting" do
   assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
 end
@@ -29,7 +29,7 @@ Or, you can enable all the tests by commenting out the
 `ExUnit.configure` line in the test suite.
 
 ```elixir
-# ExUnit.configure trace: true
+# ExUnit.configure exclude: :pending, trace: true
 ```
 
 For more detailed information about the Elixir track, please

data/tracks/elixir/docs/TESTS.md

@@ -14,12 +14,12 @@ $ elixir bob_test.exs
 In the test suites, all but the first test have been skipped.
 
 Once you get a test passing, you can unskip the next one by
-commenting out the relevant `@tag :skip` with a `#` symbol.
+commenting out the relevant `@tag :pending` with a `#` symbol.
 
 For example:
 
 ```elixir
-# @tag :skip
+# @tag :pending
 test "shouting" do
   assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
 end
@@ -29,5 +29,5 @@ Or, you can enable all the tests by commenting out the
 `ExUnit.configure` line in the test suite.
 
 ```elixir
-# ExUnit.configure trace: true
+# ExUnit.configure exclude: :pending, trace: true
 ```

data/tracks/elixir/exercises/accumulate/accumulate_test.exs

@@ -3,7 +3,7 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule AccumulateTest do
   use ExUnit.Case
@@ -12,18 +12,18 @@ defmodule AccumulateTest do
     assert Accumulate.accumulate([], fn(n) -> n * n end) == []
   end
 
-  @tag :skip
+  @tag :pending
   test "accumulate square numbers" do
     assert Accumulate.accumulate([1, 2, 3], fn(n) -> n * n end) == [1, 4, 9]
   end
 
-  @tag :skip
+  @tag :pending
   test "accumulate upcased strings" do
     fun = fn(w) -> String.upcase(w) end
     assert Accumulate.accumulate(["hello", "world"], fun) == ["HELLO", "WORLD"]
   end
 
-  @tag :skip
+  @tag :pending
   test "accumulate reversed strings" do
     fun = fn(w) -> String.reverse(w) end
     words = ~w(the quick brown fox etc)
@@ -31,11 +31,11 @@ defmodule AccumulateTest do
     assert Accumulate.accumulate(words, fun) == expected
   end
 
-  @tag :skip
-  test "accumulate recursively" do
+  @tag :pending
+  test "nested accumulate" do
     chars = ~w(a b c)
     nums  = ~w(1 2 3)
-    fun = fn(c) -> for num <- nums, do: c <> num end
+    fun = fn(c) -> Accumulate.accumulate(nums, &(c <> &1)) end
     expected = [["a1", "a2", "a3"], ["b1", "b2", "b3"], ["c1", "c2", "c3"]]
     assert Accumulate.accumulate(chars, fun) == expected
   end

data/tracks/elixir/exercises/acronym/acronym_test.exs

@@ -3,7 +3,7 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule AcronymTest do
   use ExUnit.Case
@@ -12,22 +12,22 @@ defmodule AcronymTest do
     assert Acronym.abbreviate("Portable Networks Graphic") === "PNG"
   end
 
-  @tag :skip
+  @tag :pending
   test "it produces acronyms from lower case" do
     assert Acronym.abbreviate("Ruby on Rails") === "ROR"
   end
 
-  @tag :skip
+  @tag :pending
   test "it produces acronyms from inconsistent case" do
     assert Acronym.abbreviate("HyperText Markup Language") === "HTML"
   end
 
-  @tag :skip
+  @tag :pending
   test "it ignores punctuation" do
     assert Acronym.abbreviate("First in, First out") === "FIFO"
   end
 
-  @tag :skip
+  @tag :pending
   test "it produces acronyms ignoring punctuation and casing" do
     assert Acronym.abbreviate("Complementary Metal-Oxide semiconductor") === "CMOS"
   end

data/tracks/elixir/exercises/allergies/allergies_test.exs

@@ -4,69 +4,69 @@ end
 
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule AllergiesTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "no_allergies_at_all" do
     Allergies.list(0) |> assert_is_a_set_containing([])
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_just_eggs" do
     Allergies.list(1) |> assert_is_a_set_containing(~w[eggs])
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_just_peanuts" do
     Allergies.list(2) |> assert_is_a_set_containing(~w[peanuts])
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_just_strawberries" do
     Allergies.list(8) |> assert_is_a_set_containing(~w[strawberries])
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_eggs_and_peanuts" do
     Allergies.list(3) |> assert_is_a_set_containing(~w[eggs peanuts])
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_more_than_eggs_but_not_peanuts" do
     Allergies.list(5) |> assert_is_a_set_containing(~w[eggs shellfish])
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_lots_of_stuff" do
     Allergies.list(248) |> assert_is_a_set_containing(~w[strawberries tomatoes chocolate pollen cats])
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_everything" do
     Allergies.list(255) |> assert_is_a_set_containing(~w[eggs peanuts shellfish strawberries tomatoes chocolate pollen cats])
   end
 
-  @tag :skip
+  @tag :pending
   test "no_allergies_means_not_allergic" do
     refute Allergies.allergic_to?(0, "peanuts")
     refute Allergies.allergic_to?(0, "cats")
     refute Allergies.allergic_to?(0, "strawberries")
   end
 
-  @tag :skip
+  @tag :pending
   test "is_allergic_to_eggs" do
     assert Allergies.allergic_to?(1, "eggs")
   end
 
-  @tag :skip
+  @tag :pending
   test "allergic_to_eggs_in_addition_to_other_stuff" do
     assert Allergies.allergic_to?(5, "eggs")
   end
 
-  @tag :skip
+  @tag :pending
   test "ignore_non_allergen_score_parts" do
     Allergies.list(509) |> assert_is_a_set_containing(~w[eggs shellfish strawberries tomatoes chocolate pollen cats])
   end

data/tracks/elixir/exercises/anagram/anagram_test.exs

@@ -3,72 +3,72 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule AnagramTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "no matches" do
     matches = Anagram.match "diaper", ["hello", "world", "zombies", "pants"]
     assert matches == []
   end
 
-  @tag :skip
+  @tag :pending
   test "detect simple anagram" do
     matches = Anagram.match "ant", ["tan", "stand", "at"]
     assert matches == ["tan"]
   end
 
-  @tag :skip
+  @tag :pending
   test "detect multiple anagrams" do
     matches = Anagram.match "master", ["stream", "pigeon", "maters"]
     assert matches == ["stream", "maters"]
   end
 
-  @tag :skip
+  @tag :pending
   test "do not detect anagram subsets" do
     matches = Anagram.match "good", ~w(dog goody)
     assert matches == []
   end
 
-  @tag :skip
+  @tag :pending
   test "detect anagram" do
     matches = Anagram.match "listen", ~w(enlists google inlets banana)
     assert matches == ["inlets"]
   end
 
-  @tag :skip
+  @tag :pending
   test "multiple anagrams" do
     matches = Anagram.match "allergy", ~w(gallery ballerina regally clergy largely leading)
     assert matches == ["gallery", "regally", "largely"]
   end
 
-  @tag :skip
+  @tag :pending
   test "anagrams must use all letters exactly once" do
     matches = Anagram.match "patter", ["tapper"]
     assert matches == []
   end
 
-  @tag :skip
+  @tag :pending
   test "detect anagrams with case-insensitive subject" do
     matches = Anagram.match "Orchestra", ~w(cashregister carthorse radishes)
     assert matches == ["carthorse"]
   end
 
-  @tag :skip
+  @tag :pending
   test "detect anagrams with case-insensitive candidate" do
     matches = Anagram.match "orchestra", ~w(cashregister Carthorse radishes)
     assert matches == ["Carthorse"]
   end
 
-  @tag :skip
+  @tag :pending
   test "anagrams must not be the source word" do
     matches = Anagram.match "corn", ["corn", "dark", "Corn", "rank", "CORN", "cron", "park"]
     assert matches == ["cron"]
   end
 
-  @tag :skip
+  @tag :pending
   test "do not detect words based on checksum" do
     matches = Anagram.match "mass", ["last"]
     assert matches == []

data/tracks/elixir/exercises/atbash-cipher/atbash_cipher_test.exs

@@ -3,47 +3,47 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule AtbashTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "encode no" do
     assert Atbash.encode("no") == "ml"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode yes" do
     assert Atbash.encode("yes") == "bvh"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode OMG" do
     assert Atbash.encode("OMG") == "lnt"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode O M G" do
     assert Atbash.encode("O M G") == "lnt"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode long word" do
     assert Atbash.encode("mindblowingly") == "nrmwy oldrm tob"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode numbers" do
     assert Atbash.encode("Testing, 1 2 3, testing.") == "gvhgr mt123 gvhgr mt"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode sentence" do
     assert Atbash.encode("Truth is fiction.") == "gifgs rhurx grlm"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode all the things" do
     plaintext = "The quick brown fox jumps over the lazy dog."
     cipher = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"