trackler 2.2.1.172 → 2.2.1.173

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e0c296a35d14811283022f1b7c0d4632d192794
-  data.tar.gz: 824e6e6fc0a08cb04754baca3e36435af840c13c
+  metadata.gz: 6d13933224507907acc39a988d4809740f7077b1
+  data.tar.gz: 33199102a4c7cc41ec9a584c1c23c32eaafecbbf
 SHA512:
-  metadata.gz: e3aab4d9b282d0b7d8609ed74298f52da02b974eedfea2e32d8cdfc95453a8b31203dc97e278bbf484e4060dff128a0b23264bad371412aaa43bd41c0178deba
-  data.tar.gz: 58170622fc1a49bf03c7dc3944f7b353bc5846c000ac94e6959405dfb6a9722e0142841e8f3d4548a677f967658a271bcbaa08e6f097efa17990fb566cc8f98a
+  metadata.gz: 2b440036683246536de3cb0195d0ff8e81dcd878e518bce7072f96dbc797fff077176f8d7e0dd99171151ed273826a2c2afa2311a89bd7da1eddde47a0d7c0d9
+  data.tar.gz: b7bcafde26e04dd3024c2e59c953a3e02d49aa4dcc9a49e8531e59b78756f8361e895e1b2f5c83a70d0d87b3580ac1a34aa56019b767e541915600acaa54be7d

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.172"
+  VERSION = "2.2.1.173"
 end

data/tracks/ballerina/docs/ABOUT.md

@@ -0,0 +1,2 @@
+[Ballerina](https://ballerina.io/) is a compiled, transactional, statically and strongly typed programming language with textual and graphical syntaxes. Ballerina incorporates fundamental concepts of distributed system integration into the language and offers a type safe, concurrent environment to implement microservices with distributed transactions, reliable messaging, stream processing, and workflows. 
+

data/tracks/ballerina/docs/INSTALLATION.md

@@ -0,0 +1 @@
+You can install Ballerina by following the Ballerina [installation guide](https://ballerina.io/learn/getting-started/). 

data/tracks/ballerina/docs/LEARNING.md

@@ -0,0 +1 @@
+Ballerina [learn](https://ballerina.io/learn/#learning-ballerina) page contains multiple resource you to get up to speed with the language, master the concepts and build comprehensive real world use cases. 

data/tracks/ballerina/docs/TESTS.md

@@ -0,0 +1,132 @@
+# Running the Tests
+
+Choose your operating system:
+
+* [Windows](#windows)
+* [Mac OS X](#mac-os-x)
+* [Linux](#linux)
+
+----
+
+# Windows
+
+1. Open a Command Prompt and get the first exercise:
+
+     ```batchfile
+     C:\Users\JohnDoe>exercism fetch ballerina
+
+     Not Submitted:     1 problem
+     ballerina (Hello World) C:\Users\JohnDoe\exercism\ballerina\hello-world
+
+     New:               1 problem
+     ballerina (Hello World) C:\Users\JohnDoe\exercism\ballerina\hello-world
+
+     unchanged: 0, updated: 0, new: 1
+   ```
+
+2. Change directory into the ballerina exercism main directory:
+
+     ```batchfile
+     C:\Users\JohnDoe>cd C:\Users\JohnDoe\exercism\ballerina
+     ```
+3. Initialize the project prior to executing tests:
+
+     ```batchfile
+     C:\Users\JohnDoe\exercism\ballerina> ballerina init
+     ```
+     
+4. Run the tests:
+
+     ```batchfile
+     C:\Users\JohnDoe\exercism\ballerina>ballerina test hello-world 
+     ```
+   *(Don't worry about the tests failing, at first, this is how you begin each exercise.)*
+
+5. Solve the exercise.  Find and work through the `TUTORIAL.md` guide ([view on GitHub](https://github.com/exercism/ballerina/blob/master/exercises/hello-world/TUTORIAL.md)).
+
+
+Good luck!  Have fun!
+
+If you get stuck, at any point, don't forget to reach out for [help](http://exercism.io/languages/ballerina/help).
+
+----
+
+# Mac OS X
+
+1. In the terminal window, get the first exercise:
+
+     ```
+     $ exercism fetch ballerina
+
+     New:                 1 problem
+     ballerina (Etl) /Users/johndoe/exercism/ballerina/hello-world
+
+     unchanged: 0, updated: 0, new: 1
+    ```
+
+2. Change directory into the ballerina exercism main directory:
+
+     ```
+     $ cd /Users/johndoe/exercism/ballerina
+     ```
+
+
+3. Initialize the project prior to executing tests:
+
+     ```batchfile
+     /Users/johndoe/exercism/ballerina $ ballerina init
+     ```
+
+4. Run the tests:
+
+    ```
+    /Users/johndoe/exercism/ballerina $ ballerina test hello-world
+    ```
+   *(Don't worry about the tests failing, at first, this is how you begin each exercise.)*
+
+5. Solve the exercise.  Find and work through the `TUTORIAL.md` guide ([view on GitHub](https://github.com/exercism/ballerina/blob/master/exercises/hello-world/TUTORIAL.md)).
+
+Good luck!  Have fun!
+
+If you get stuck, at any point, don't forget to reach out for [help](http://exercism.io/languages/ballerina/help).
+
+----
+
+# Linux
+
+1. In the terminal window, get the first exercise:
+
+     ```
+     $ exercism fetch ballerina
+
+     New:                 1 problem
+     ballerina (Etl) /home/johndoe/exercism/ballerina/hello-world
+
+     unchanged: 0, updated: 0, new: 1
+
+    ```
+
+2. Change directory into the exercise:
+
+     ```
+     $ cd /home/johndoe/exercism/ballerina/hello-world
+     ```
+
+3. Initialize the project prior to executing tests:
+
+     ```batchfile
+     /home/johndoe/exercism/ballerina $ ballerina init
+     ```
+
+4. Run the tests:
+
+    ```
+    /home/johndoe/exercism/ballerina $ ballerina test hello-world
+    ```
+   *(Don't worry about the tests failing, at first, this is how you begin each exercise.)*
+
+5. Solve the exercise.  Find and work through the `TUTORIAL.md` guide ([view on GitHub](https://github.com/exercism/ballerina/blob/master/exercises/hello-world/TUTORIAL.md)).
+
+Good luck!  Have fun!
+
+If you get stuck, at any point, don't forget to reach out for [help](http://exercism.io/languages/ballerina/help).

data/tracks/common-lisp/README.md

@@ -1,11 +1,11 @@
-# xLisp
+# Common Lisp
 
 [![Build Status](https://travis-ci.org/exercism/common-lisp.svg)](https://travis-ci.org/exercism/common-lisp)
 
 Exercism exercises in Lisp
 
 
-## Contributing To the Common Lisp Track
+## Contributing to the Common Lisp Track
 
 ### Contributing Guide
 

data/tracks/common-lisp/docs/SNIPPET.txt

@@ -1,11 +1,7 @@
-(defpackage #:hamming
-  (:use #:common-lisp)
-  (:export #:distance))
-
-(in-package #:hamming)
-
-(defun distance (str1 str2 &key (test #'char=))
-  "Number of positional differences in two equal length strings."
+(defun distance (str1 str2
+                 &key (test #'char=))
+  "Number of positional differences in
+   two equal length strings."
   (when (= (length str1) (length str2))
     (count nil
            (map 'list test str1 str2))))

data/tracks/factor/config.json

@@ -8,6 +8,7 @@
       "slug": "hello-world",
       "uuid": "c81c4175-f06b-404d-8c01-c4a6dba661d3",
       "core": false,
+      "auto_approve": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [

data/tracks/haskell/config.json

@@ -1,7 +1,7 @@
 {
   "language": "Haskell",
   "active": true,
-  "blurb": "",
+  "blurb": "Haskell is a functional programming language which is pure and statically-typed. It's known for lazy evaluation, where evaluation is deferred until necessary, and its purity, where monads are used for working with side-effects.",
   "ignore_pattern": "example",
   "solution_pattern": "example.*[.]hs",
   "exercises": [
@@ -9,6 +9,7 @@
       "slug": "hello-world",
       "uuid": "c97d9dda-c7ee-4595-b447-693559d03ba5",
       "core": false,
+      "auto_approve": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": null

data/tracks/nim/exercises/allergies/allergies_test.nim

@@ -3,66 +3,65 @@ import unittest
 import allergies
 
 
-test "no allergies means not allergic":
+suite "Allergies":
+
+  test "no allergies means not allergic":
     let allergies = Allergies(score: 0)
     check allergies.isAllergicTo("peanuts") == false
     check allergies.isAllergicTo("cats") == false
     check allergies.isAllergicTo("strawberries") == false
 
-test "is allergic to eggs":
+  test "is allergic to eggs":
     let allergies = Allergies(score: 1)
     check allergies.isAllergicTo("eggs") == true
 
-test "allergic to eggs in addition to other stuff":
+  test "allergic to eggs in addition to other stuff":
     let allergies = Allergies(score: 5)
     check allergies.isAllergicTo("eggs") == true
     check allergies.isAllergicTo("shellfish") == true
     check allergies.isAllergicTo("strawberries") == false
 
-test "no allergies at all":
+  test "no allergies at all":
     let allergies = Allergies(score: 0)
     check allergies.lst == newSeq[string](0)
 
-test "allergic to just eggs":
+  test "allergic to just eggs":
     let allergies = Allergies(score: 1)
     check allergies.lst == @["eggs"]
 
-test "allergic to just peanuts":
+  test "allergic to just peanuts":
     let allergies = Allergies(score: 2)
     check allergies.lst == @["peanuts"]
 
-test "allergic to just strawberries":
+  test "allergic to just strawberries":
     let allergies = Allergies(score: 8)
     check allergies.lst == @["strawberries"]
 
-test "allergic to eggs and peanuts":
+  test "allergic to eggs and peanuts":
     let allergies = Allergies(score: 3)
     check allergies.lst == @["eggs", "peanuts"]
 
-test "allergic to more than eggs but not peanuts":
+  test "allergic to more than eggs but not peanuts":
     let allergies = Allergies(score: 5)
     check allergies.lst == @["eggs", "shellfish"]
 
-test "allergic to lots of stuff":
+  test "allergic to lots of stuff":
     let allergies = Allergies(score: 248)
     check allergies.lst == @[
-        "strawberries", "tomatoes", "chocolate", "pollen", "cats"
-        ]
+      "strawberries", "tomatoes", "chocolate", "pollen", "cats"]
 
-test "allergic to everything":
+  test "allergic to everything":
     let allergies = Allergies(score: 255)
     check allergies.lst == @[
-            "eggs", "peanuts", "shellfish", "strawberries", "tomatoes",
-            "chocolate", "pollen", "cats"
-            ]
+        "eggs", "peanuts", "shellfish", "strawberries", "tomatoes",
+        "chocolate", "pollen", "cats"]
 
-test "ignore non allergen score parts only eggs":
+  test "ignore non allergen score parts only eggs":
     let allergies = Allergies(score: 257)
     check allergies.lst == @["eggs"]
 
-test "ignore non allergen score parts":
+  test "ignore non allergen score parts":
     let allergies = Allergies(score: 509)
     check allergies.lst == @[
-            "eggs", "shellfish", "strawberries", "tomatoes", "chocolate",
-            "pollen", "cats"
-        ]
+        "eggs", "shellfish", "strawberries", "tomatoes", "chocolate",
+        "pollen", "cats"]

data/tracks/nim/exercises/anagram/anagram_test.nim

@@ -1,74 +1,76 @@
 import unittest
 from anagram import detectAnagrams
 
-test "no matches":
-  let
-    word = "diaper"
-    candidates = @["hello", "world", "zombies", "pants"]
-    expected: seq[string] = @[]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+suite "Anagram":
+  
+  test "no matches":
+    let
+      word = "diaper"
+      candidates = @["hello", "world", "zombies", "pants"]
+      expected: seq[string] = @[]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "detect simple anagram":
-  let
-    word = "ant"
-    candidates = @["tan", "stand", "at"]
-    expected = @["tan"]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "detect simple anagram":
+    let
+      word = "ant"
+      candidates = @["tan", "stand", "at"]
+      expected = @["tan"]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "detect multiple anagrams":
-  let
-    word = "master"
-    candidates = @["stream", "pigeon", "maters"]
-    expected = @["stream", "maters"]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "detect multiple anagrams":
+    let
+      word = "master"
+      candidates = @["stream", "pigeon", "maters"]
+      expected = @["stream", "maters"]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "does not confuse different duplicate characters":
-  let
-    word = "galea"
-    candidates = @["eagle"]
-    expected: seq[string] = @[]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "does not confuse different duplicate characters":
+    let
+      word = "galea"
+      candidates = @["eagle"]
+      expected: seq[string] = @[]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "eliminate anagram subsets":
-  let
-    word = "good"
-    candidates = @["dog", "goody"]
-    expected: seq[string] = @[]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "eliminate anagram subsets":
+    let
+      word = "good"
+      candidates = @["dog", "goody"]
+      expected: seq[string] = @[]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "detect anagram":
-  let
-    word = "listen"
-    candidates = @["enlists", "google", "inlets", "banana"]
-    expected = @["inlets"]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "detect anagram":
+    let
+      word = "listen"
+      candidates = @["enlists", "google", "inlets", "banana"]
+      expected = @["inlets"]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "multiple anagrams":
-  let
-    word = "allergy"
-    candidates = @["gallery", "ballerina", "regally", "clergy", "largely", "leading"]
-    expected = @["gallery", "regally", "largely"]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "multiple anagrams":
+    let
+      word = "allergy"
+      candidates = @["gallery", "ballerina", "regally", "clergy", "largely", "leading"]
+      expected = @["gallery", "regally", "largely"]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "anagrams are case insensitive":
-  let
-    word = "Orchestra"
-    candidates = @["cashregister", "Carthorse", "radishes"]
-    expected = @["Carthorse"]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "anagrams are case insensitive":
+    let
+      word = "Orchestra"
+      candidates = @["cashregister", "Carthorse", "radishes"]
+      expected = @["Carthorse"]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected
 
-test "same word isn't anagram":
-  let
-    word = "go"
-    candidates = @["go", "Go", "GO"]
-    expected: seq[string] = @[]
-    detected = detectAnagrams(word, candidates)
-  check detected == expected
+  test "same word isn't anagram":
+    let
+      word = "go"
+      candidates = @["go", "Go", "GO"]
+      expected: seq[string] = @[]
+      detected = detectAnagrams(word, candidates)
+    check detected == expected

data/tracks/nim/exercises/binary/binary_test.nim

@@ -1,54 +1,55 @@
 import unittest
 import binary
 
+suite "Binary":
 
-test "binary 0 is decimal 0":
-  check binary("0") == 0
+  test "binary 0 is decimal 0":
+    check binary("0") == 0
 
-test "binary 1 is decimal 1":
-  check binary("1") == 1
+  test "binary 1 is decimal 1":
+    check binary("1") == 1
 
-test "binary 10 is decimal 2":
-  check binary("10") == 2
+  test "binary 10 is decimal 2":
+    check binary("10") == 2
 
-test "binary 11 is decimal 3":
-  check binary("11") == 3
+  test "binary 11 is decimal 3":
+    check binary("11") == 3
 
-test "binary 100 is decimal 4":
-  check binary("100") == 4
+  test "binary 100 is decimal 4":
+    check binary("100") == 4
 
-test "binary 1001 is decimal 9":
-  check binary("1001") == 9
+  test "binary 1001 is decimal 9":
+    check binary("1001") == 9
 
-test "binary 11010 is decimal 26":
-  check binary("11010") == 26
+  test "binary 11010 is decimal 26":
+    check binary("11010") == 26
 
-test "binary 10001101000 is decimal 1128":
-  check binary("10001101000") == 1128
+  test "binary 10001101000 is decimal 1128":
+    check binary("10001101000") == 1128
 
-test "binary ignores leading zeros":
-  check binary("000011111") == 31
+  test "binary ignores leading zeros":
+    check binary("000011111") == 31
 
-test "2 is not a valid binary digit":
-  expect(ValueError):
-    discard binary("2")
+  test "2 is not a valid binary digit":
+    expect(ValueError):
+      discard binary("2")
 
-test "a number containing a non-binary digit is invalid":
-  expect(ValueError):
-    discard binary("01201")
+  test "a number containing a non-binary digit is invalid":
+    expect(ValueError):
+      discard binary("01201")
 
-test "a number with trailing non-binary characters is invalid":
-  expect(ValueError):
-    discard binary("10nope")
+  test "a number with trailing non-binary characters is invalid":
+    expect(ValueError):
+      discard binary("10nope")
 
-test "a number with leading non-binary characters is invalid":
-  expect(ValueError):
-    discard binary("nope10")
+  test "a number with leading non-binary characters is invalid":
+    expect(ValueError):
+      discard binary("nope10")
 
-test "a number with internal non-binary characters is invalid":
-  expect(ValueError):
-    discard binary("10nope10")
+  test "a number with internal non-binary characters is invalid":
+    expect(ValueError):
+      discard binary("10nope10")
 
-test "a number and a word whitespace spearated is invalid":
-  expect(ValueError):
-    discard binary("001 nope")
+  test "a number and a word whitespace spearated is invalid":
+    expect(ValueError):
+      discard binary("001 nope")

data/tracks/nim/exercises/bob/bob_test.nim

@@ -2,7 +2,7 @@ import unittest
 
 import bob
 
-suite "hey tests":
+suite "Bob":
 
   test "stating something":
     check hey("Tom-ay-to, tom-aaaah-to.") == "Whatever."

data/tracks/nim/exercises/bracket-push/bracket_push_test.nim

@@ -2,7 +2,7 @@ import unittest
 
 import bracket_push
 
-suite "bracket-push":
+suite "Bracket Push":
 
   test "paired square brackets":
     check isPaired("[]") == true

data/tracks/nim/exercises/difference-of-squares/difference_of_squares_test.nim

@@ -1,20 +1,22 @@
 import unittest
 import difference_of_squares
 
-test "square of sum, 5":
-  check squareOfSum(5) == 225
+suite "Difference of Squares":
 
-test "sum of squares, 5":
-  check sumOfSquares(5) == 55
+  test "square of sum, 5":
+    check squareOfSum(5) == 225
 
-test "difference, 5":
-  check difference(5) == 170
+  test "sum of squares, 5":
+    check sumOfSquares(5) == 55
 
-test "square of sum, 100":
-  check squareOfSum(100) == 25502500
+  test "difference, 5":
+    check difference(5) == 170
 
-test "sum of squares, 100":
-  check sumOfSquares(100) == 338350
+  test "square of sum, 100":
+    check squareOfSum(100) == 25502500
 
-test "difference, 100":
-  check difference(100) == 25164150
+  test "sum of squares, 100":
+    check sumOfSquares(100) == 338350
+
+  test "difference, 100":
+    check difference(100) == 25164150

data/tracks/nim/exercises/gigasecond/example.nim

@@ -1,4 +1,4 @@
 import times
 
 proc addGigasecond*(date: DateTime): DateTime =
-    date + initInterval(seconds=1_000_000_000)
+  date + initInterval(seconds=1_000_000_000)

data/tracks/nim/exercises/gigasecond/gigasecond_test.nim

@@ -4,29 +4,29 @@ import gigasecond
 
 suite "Gigasecond":
 
-    test "date only specification of time":
-        let birthday = initDateTime(25, mApr, 2011, 0, 0, 0, utc())
-        let expected = initDateTime(1, mJan, 2043, 1, 46, 40, utc())
-        check addGigasecond(birthday) == expected
-
-    test "second test for date only specification of time":
-        let birthday = initDateTime(13, mJun, 1977, 0, 0, 0, utc())
-        let expected = initDateTime(19, mFeb, 2009, 1, 46, 40, utc())
-        check addGigasecond(birthday) == expected
-
-    test "third test for date only specification of time":
-        let birthday = initDateTime(19, mJul, 1959, 0, 0, 0, utc())
-        let expected = initDateTime(27, mMar, 1991, 1, 46, 40, utc())
-        check addGigasecond(birthday) == expected
-
-    test "full time specified":
-        let birthday = initDateTime(24, mJan, 2015, 22, 0, 0, utc())
-        let expected = initDateTime(2, mOct, 2046, 23, 46, 40, utc())
-        check addGigasecond(birthday) == expected
-
-    test "full time with day roll-over":
-        let birthday = initDateTime(24, mJan, 2015, 23, 59, 59, utc())
-        let expected = initDateTime(3, mOct, 2046, 1, 46, 39, utc())
-        check addGigasecond(birthday) == expected
+  test "date only specification of time":
+    let birthday = initDateTime(25, mApr, 2011, 0, 0, 0, utc())
+    let expected = initDateTime(1, mJan, 2043, 1, 46, 40, utc())
+    check addGigasecond(birthday) == expected
+
+  test "second test for date only specification of time":
+    let birthday = initDateTime(13, mJun, 1977, 0, 0, 0, utc())
+    let expected = initDateTime(19, mFeb, 2009, 1, 46, 40, utc())
+    check addGigasecond(birthday) == expected
+
+  test "third test for date only specification of time":
+    let birthday = initDateTime(19, mJul, 1959, 0, 0, 0, utc())
+    let expected = initDateTime(27, mMar, 1991, 1, 46, 40, utc())
+    check addGigasecond(birthday) == expected
+
+  test "full time specified":
+    let birthday = initDateTime(24, mJan, 2015, 22, 0, 0, utc())
+    let expected = initDateTime(2, mOct, 2046, 23, 46, 40, utc())
+    check addGigasecond(birthday) == expected
+
+  test "full time with day roll-over":
+    let birthday = initDateTime(24, mJan, 2015, 23, 59, 59, utc())
+    let expected = initDateTime(3, mOct, 2046, 1, 46, 39, utc())
+    check addGigasecond(birthday) == expected