trackler 1.0.1.0 → 1.0.1.1

data/tracks/clojure/_test/check_exercises.clj

@@ -6,9 +6,10 @@
 (defn- ->snake_case [s] (string/replace s \- \_))
 
 (deftest check-exercises
-  (doseq [problem ((json/parse-string (slurp "config.json")) "problems")
-          :let [path-to-problem (partial str "exercises/" problem "/")
-                problem-tests   (symbol (str problem "-test"))]]
-    (load-file (path-to-problem "src/example.clj"))
-    (load-file (path-to-problem "test/" (->snake_case problem) "_test.clj"))
-    (is (successful? (run-tests problem-tests)))))
+  (doseq [exercise ((json/parse-string (slurp "config.json")) "exercises")
+          :let [slug             (exercise "slug")
+                path-to-exercise (partial str "exercises/" slug "/")
+                exercise-tests   (symbol (str slug "-test"))]]
+    (load-file (path-to-exercise "src/example.clj"))
+    (load-file (path-to-exercise "test/" (->snake_case slug) "_test.clj"))
+    (is (successful? (run-tests exercise-tests)))))

data/tracks/clojure/config.json

@@ -3,59 +3,6 @@
   "language": "Clojure",
   "repository": "https://github.com/exercism/xclojure",
   "active": true,
-  "problems": [
-    "hello-world",
-    "bob",
-    "rna-transcription",
-    "word-count",
-    "anagram",
-    "beer-song",
-    "nucleotide-count",
-    "hamming",
-    "phone-number",
-    "grade-school",
-    "robot-name",
-    "leap",
-    "etl",
-    "binary-search",
-    "meetup",
-    "space-age",
-    "grains",
-    "gigasecond",
-    "triangle",
-    "scrabble-score",
-    "roman-numerals",
-    "binary",
-    "trinary",
-    "prime-factors",
-    "raindrops",
-    "allergies",
-    "octal",
-    "strain",
-    "atbash-cipher",
-    "bank-account",
-    "crypto-square",
-    "pascals-triangle",
-    "sum-of-multiples",
-    "sieve",
-    "luhn",
-    "kindergarten-garden",
-    "robot-simulator",
-    "queen-attack",
-    "accumulate",
-    "binary-search-tree",
-    "difference-of-squares",
-    "hexadecimal",
-    "all-your-base",
-    "largest-series-product",
-    "pov",
-    "bracket-push",
-    "minesweeper",
-    "change",
-    "pangram",
-    "wordy",
-    "isogram"
-  ],
   "deprecated": [
 
   ],
@@ -66,5 +13,273 @@
     "img"
   ],
   "foregone": [
+
+  ],
+  "exercises": [
+    {
+      "difficulty": 1,
+      "slug": "hello-world",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "bob",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "rna-transcription",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "word-count",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "anagram",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "beer-song",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "nucleotide-count",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "hamming",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "phone-number",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "grade-school",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "robot-name",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "leap",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "etl",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "flatten-array",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "binary-search",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "perfect-numbers",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "meetup",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "space-age",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "grains",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "gigasecond",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "triangle",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "scrabble-score",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "roman-numerals",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "binary",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "trinary",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "prime-factors",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "raindrops",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "allergies",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "octal",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "strain",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "atbash-cipher",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "bank-account",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "crypto-square",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "pascals-triangle",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "sum-of-multiples",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "sieve",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "luhn",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "kindergarten-garden",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "robot-simulator",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "queen-attack",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "accumulate",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "binary-search-tree",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "difference-of-squares",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "hexadecimal",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "all-your-base",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "largest-series-product",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "pov",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "bracket-push",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "minesweeper",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "change",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "pangram",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "wordy",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "isogram",
+      "topics": []
+    }
   ]
 }

data/tracks/clojure/exercises/flatten-array/src/example.clj

@@ -0,0 +1,16 @@
+(ns flatten-array
+  (:refer-clojure :exclude [flatten]))
+
+(defn flatten
+  "Flattens the given list and removes any nil values"
+  [coll]
+  (loop
+   [results nil
+    [elem & remaining] coll]
+    (if (or elem remaining)
+      (if (coll? elem)
+        (if (empty? elem)
+          (recur results remaining)
+          (recur results (conj remaining (rest elem) (first elem))))
+        (recur (conj results elem) remaining))
+      (reverse (remove nil? results)))))

data/tracks/clojure/exercises/flatten-array/test/flatten_array_test.clj

@@ -0,0 +1,28 @@
+(ns flatten-array-test
+  (require [clojure.test :refer [deftest is testing]]
+           [flatten-array]))
+
+(deftest flattens-array-of-ints
+  (testing "flattens array with just integers present"
+    (is (= [1 2 3 4 5 6 7 8]
+           (flatten-array/flatten [1 [2 3 4 5 6 7] 8])))))
+
+(deftest five-level-nesting
+  (testing "5 level nested list"
+    (is (= [0 2 2 3 8 100 4 50 -2]
+           (flatten-array/flatten [0 2 [[2 3] 8 100 4 [[[50]]]] -2])))))
+
+(deftest six-level-nesting
+  (testing "6 level nested list"
+    (is (= [1 2 3 4 5 6 7 8]
+           (flatten-array/flatten [1 [2 [[3]] [4 [[5]]] 6 7] 8])))))
+
+(deftest six-level-nested-with-nils
+  (testing "6 level nested list with nil values"
+    (is (= [0 2 2 3 8 100 -2]
+           (flatten-array/flatten [0 2 [[2 3] 8 [[100]] nil [[nil]]] -2])))))
+
+(deftest all-nils-list
+  (testing "All values in nested list are nil"
+    (is (empty?
+          (flatten-array/flatten [nil [[[nil]]] nil nil [[nil nil] nil] nil])))))

data/tracks/clojure/exercises/perfect-numbers/project.clj

@@ -0,0 +1,4 @@
+(defproject perfect-numbers "0.1.0-SNAPSHOT"
+  :description "perfect-numbers exercise."
+  :url "https://github.com/exercism/xclojure/tree/master/exercises/perfect-numbers"
+  :dependencies [[org.clojure/clojure "1.8.0"]])

data/tracks/clojure/exercises/perfect-numbers/src/example.clj

@@ -0,0 +1,17 @@
+(ns perfect-numbers)
+
+(defn- get-divisors
+  "Utility function to get the divisors of a number"
+  [number]
+  (for [n (range 1 (inc (quot number 2))) :when (zero? (mod number n))]
+    n))
+
+(defn classify [number]
+  "Classifies a positive integer as deficient, abundant or perfect"
+  (if-not (pos? number)
+    (throw (IllegalArgumentException. "Only positive numbers can be classified."))
+    (let [divisor-sum (apply + (get-divisors number))]
+      (cond
+        (> divisor-sum number) :abundant
+        (< divisor-sum number) :deficient
+        (= divisor-sum number) :perfect))))

data/tracks/clojure/exercises/perfect-numbers/test/perfect_numbers_test.clj

@@ -0,0 +1,20 @@
+(ns perfect-numbers-test
+  (:require
+    [clojure.test :refer [deftest testing is]]
+    [perfect-numbers]))
+
+(deftest test-initialize-perfect-number
+  (testing "Negative numbers throw an exception"
+    (is (thrown? IllegalArgumentException (perfect-numbers/classify -1)))))
+
+(deftest test-classify-deficient
+  (testing "13 is a deficient number"
+    (is (= :deficient (perfect-numbers/classify 13)))))
+
+(deftest test-classify-perfect
+  (testing "28 is a perfect number"
+    (is (= :perfect (perfect-numbers/classify 28)))))
+
+(deftest test-classify-abundant
+  (testing "12 is an abundant number"
+    (is (= :abundant (perfect-numbers/classify 12)))))

data/tracks/ecmascript/exercises/grade-school/grade-school.spec.js

@@ -70,4 +70,11 @@ describe('School', () => {
     expect(school.roster()).toEqual(expectedDb);
   });
 
+  xit('roster cannot be modified outside of module using grade()', () => {
+    school.add('Aimee', 2);
+    school.grade(2).push('Oops.');
+    const expectedDb = { 2 : [ 'Aimee' ] };
+    expect(school.roster()).toEqual(expectedDb);
+  });
+
 });

data/tracks/elixir/.travis.yml

@@ -16,5 +16,8 @@ script:
 - EXERCISM_TEST_EXAMPLES=true elixirc --warnings-as-errors **/example.exs **/*_test.exs -o ./tmp > /dev/null
 - rm -rf ./tmp
 
+- bin/dialyzer_check.sh
+
 - "! git grep ' $' -- \\*.exs | grep -v -e 'exercises/diamond/diamond_test.exs'"
+
 sudo: false

data/tracks/elixir/bin/dialyzer_check.sh

@@ -0,0 +1,28 @@
+mkdir -p ./tmp/src
+mkdir ./tmp/build
+
+
+for example_file in exercises/**/example.exs
+do
+  exercise_dir=$(dirname $example_file)
+  exercise=$(basename $exercise_dir)
+  cp "$exercise_dir/example.exs" "./tmp/src/$exercise.exs"
+done
+
+elixirc -o ./tmp/build ./tmp/src/*.exs
+
+if [ $CI ]; then
+    export PLT_FILENAME=elixir-${TRAVIS_ELIXIR_VERSION:=1.3.2}_${TRAVIS_OTP_RELEASE:=19.0}.plt
+    export PLT_LOCATION=./tmp/$PLT_FILENAME
+    wget -O $PLT_LOCATION https://github.com/danielberkompas/travis_elixir_plts/blob/master/elixir-${TRAVIS_ELIXIR_VERSION}_${TRAVIS_OTP_RELEASE}.plt?raw=true
+
+    dialyzer --no_check_plt --plt $PLT_LOCATION --no_native ./tmp/build;
+    RESULT=$?
+else
+    dialyzer ./tmp/build;
+    RESULT=$?
+fi
+
+rm -rf ./tmp
+
+exit $RESULT

data/tracks/elixir/config.json

@@ -66,7 +66,8 @@
     "dot-dsl",
     "custom-set",
     "forth",
-    "pangram"
+    "pangram",
+    "clock"
   ],
   "exercises": [
     {
@@ -448,6 +449,17 @@
         "Strings",
         "Enumerations"
       ]
+    },
+    {
+      "slug": "clock",
+      "difficulty": 1,
+      "topics": [
+        "Protocols",
+        "Structs",
+        "Logic",
+        "Transforming",
+        "Integers"
+      ]
     }
   ],
   "deprecated": [

data/tracks/elixir/docs/TESTS.md

@@ -31,3 +31,84 @@ Or, you can enable all the tests by commenting out the
 ```elixir
 # ExUnit.configure exclude: :pending, trace: true
 ```
+
+### Typespecs and Dialyzer (DIscrepancy AnalYZer for ERlang programs)
+
+Elixir exercises include a skeleton implementation file. This
+file outlines the module and functions that you are expected
+to implement. In most exercises, you will find typespecs
+above the function declaration. These start with the `@spec` tag and
+typically follow the `@spec function_name(type1, type2) :: return_type`
+format. These are used in Elixir and Erlang as documentation and
+in conjunction with a tool called Dialyzer to find type inconsistencies
+and possible bugs. For more information see the
+[Elixir typespecs guide](http://elixir-lang.org/getting-started/typespecs-and-behaviours.html)
+or the [typespecs documentation](http://elixir-lang.org/docs/stable/elixir/typespecs.html). For
+documentation about Dialyzer see [Erlang -- dialyzer](http://erlang.org/doc/man/dialyzer.html).
+
+Optionally, you may want to check
+the types of your implementation with Dialyzer. There are a couple
+of steps you will need to take. Because all of the Elixir exercises
+are implemented as `.exs` script files they will not create a
+`.beam` file when they are dynamically compiled when running
+normal tests. In order to create the `.beam` file that Dialyzer
+needs to analyze run:
+
+```bash
+$ elixirc word_count.exs
+```
+
+This will create a file called `Elixir.Words.beam`. Now you can run
+Dialyzer on your implementation with:
+
+```bash
+$ dialyzer Elixir.Words.beam
+
+Checking whether the PLT ~/.dialyzer_plt is up-to-date... yes
+  Proceeding with analysis...
+  done in 0m0.27s
+done (passed successfully)
+```
+
+If this is the first time you have run Dialyzer you
+will most likely not have a `plt` file. The persistent lookup table,
+or PLT is used by Dialyzer to cache information about built in Elixir
+and Erlang types. To create a plt with sensible defaults run:
+
+
+```bash
+$ dialyzer --build_plt --apps erts kernel stdlib crypto public_key /path/to/elixir
+```
+
+Make sure to change the path to your system's path to the Elixir libraries. For
+instance, if you installed Elixir with homebrew you will probably find it under
+`/usr/local/Cellar/elixir/1.3.2`.
+
+It should be reiterated that running Dialyzer and removing all warnings
+is an optional step when completing an exercise. Dialyzer warnings can
+be difficult to decipher. For instance, examine the warnings for this very silly
+implementation of the `Bob` exercise.
+
+```elixir
+defmodule Bob do
+  @spec hey(input :: String.t) :: String.t
+  def hey(input) do
+    1
+  end
+
+  def hey(input) do
+  end
+end
+```
+
+This produces the following warnings.
+
+```bash
+bob.exs:2: Invalid type specification for function 'Elixir.Bob':hey/1. The success typing is (_) -> 1
+bob.exs:7: The variable _input@1 can never match since previous clauses completely covered the type any()
+```
+
+The first warning means that the function is not returning
+the correct type. The last indicates that the second function
+definition can never be reached because the first function
+definition always matches.

data/tracks/elixir/exercises/bank-account/example.exs

@@ -43,7 +43,7 @@ defmodule BankAccount do
   @doc """
   Close the bank. Makes the account unavailable.
   """
-  @spec close_bank(account) :: none
+  @spec close_bank(account) :: any
   def close_bank(account) do
     :gen_server.call(account, :close)
   end

data/tracks/elixir/exercises/binary-search/binary_search_test.exs

@@ -17,6 +17,11 @@ defmodule BinarySearchTest do
     assert BinarySearch.search({2, 4, 6}, 3) == :not_found
   end
 
+  @tag :pending
+  test "returns :not_found when key is too high" do
+    assert BinarySearch.search({2, 4, 6}, 9) == :not_found
+  end
+
   @tag :pending
   test "finds key in a tuple with a single item" do
     assert BinarySearch.search({3}, 3) == {:ok, 0}

data/tracks/elixir/exercises/clock/clock.exs

@@ -0,0 +1,23 @@
+defmodule Clock do
+  defstruct hour: 0, minute: 0
+
+  @doc """
+  Returns a string representation of a clock:
+
+      iex> Clock.new(8, 9) |> to_string
+      "08:09"
+  """
+  @spec new(integer, integer) :: Clock
+  def new(hour, minute) do
+  end
+
+  @doc """
+  Adds two clock times:
+
+      iex> Clock.add(10, 0) |> Clock.add(3) |> to_string
+      "10:03"
+  """
+  @spec add(Clock, integer) :: Clock
+  def add(%Clock{hour: hour, minute: minute}, add_minute) do
+  end
+end