trackler 2.0.0.1 → 2.0.0.2

data/tracks/scala/exercises/sieve/src/test/scala/SieveTest.scala

@@ -5,11 +5,13 @@ class SieveTest extends FunSuite with Matchers {
     Sieve.primesUpTo(10) should be (List(2, 3, 5, 7))
   }
 
-  test("primes up to 11") {
+  test("primes up to 11") { 
+    pending
     Sieve.primesUpTo(11) should be (List(2, 3, 5, 7, 11))
   }
 
-  test("primes up to 1000") {
+  test("primes up to 1000") { 
+    pending
     Sieve.primesUpTo(1000) should be (List(
       2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
       73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
@@ -24,11 +26,13 @@ class SieveTest extends FunSuite with Matchers {
       919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997))
   }
 
-  test("first thousand primes") {
+  test("first thousand primes") { 
+    pending
     Sieve.primesUpTo(7919).size should be (1000)
   }
 
-  test("edge cases") {
+  test("edge cases") { 
+    pending
     Sieve.primesUpTo(1) should be (List())
     Sieve.primesUpTo(2) should be (List(2))
   }

data/tracks/scala/exercises/simple-cipher/src/test/scala/CipherTest.scala

@@ -12,43 +12,51 @@ class CipherTest extends FunSuite with Matchers {
     cipher.decode(cipher.key.substring(0, 10)) should be ("aaaaaaaaaa")
   }
 
-  test("Invalid key - contains caps") {
-    intercept[IllegalArgumentException] {
+  test("Invalid key - contains caps") { 
+    pending
+    intercept[IllegalArgumentException] { 
       Cipher(Some("ABCD"))
     }
   }
 
-  test("Invalid key - contains numerics") {
+  test("Invalid key - contains numerics") { 
+    pending
     intercept[IllegalArgumentException] {
       Cipher(Some("123"))
     }
   }
 
-  test("Invalid key - is empty") {
+  test("Invalid key - is empty") { 
+    pending
     intercept[IllegalArgumentException] {
       Cipher(Some(""))
     }
   }
 
-  test("Substitution cipher - can encode") {
+  test("Substitution cipher - can encode") { 
+    pending
     Cipher(Some("abcdefghij")).encode("aaaaaaaaaa") should be ("abcdefghij")
   }
 
-  test("Substitution cipher - can decode") {
+  test("Substitution cipher - can decode") { 
+    pending
     Cipher(Some("abcdefghij")).decode("abcdefghij") should be ("aaaaaaaaaa")
   }
 
-  test("Substitution cipher - is reversible") {
+  test("Substitution cipher - is reversible") { 
+    pending
     val cipher = Cipher(Some("abcdefghij"))
     cipher.decode(cipher.encode("abcdefghij")) should be ("abcdefghij")
   }
 
-  test("Substitution cipher - can double shift") {
+  test("Substitution cipher - can double shift") { 
+    pending
     val cipher = Cipher(Some("iamapandabear"))
     cipher.encode("iamapandabear") should be ("qayaeaagaciai")
   }
 
-  test("Substitution cipher - can wrap") {
+  test("Substitution cipher - can wrap") { 
+    pending
     Cipher(Some("abcdefghij")).encode("zzzzzzzzzz") should be ("zabcdefghi")
   }
 }

data/tracks/scala/exercises/sublist/src/test/scala/sublist_test.scala

@@ -6,75 +6,92 @@ class SublistSpecs extends FunSuite with Matchers {
   }
 
   test("empty is a sublist of anything") {
+    pending
     Sublist.sublist(List(), List('a', 's', 'd', 'f')) should be (Sublist.Sublist)
   }
 
   test("anything is a superlist of empty") {
+    pending
     Sublist.sublist(List('a', 's', 'd', 'f'), List()) should be (Sublist.Superlist)
   }
 
   test("List(1) is not List(2)") {
+    pending
     Sublist.sublist(List(1), List(2)) should be (Sublist.Unequal)
   }
 
   test("compare larger equal lists") {
+    pending
     val xs = List.fill(1000)("x")
     Sublist.sublist(xs, xs) should be (Sublist.Equal)
   }
 
   test("sublist at start") {
+    pending
     Sublist.sublist(List(1, 2, 3), List(1, 2, 3, 4, 5)) should be (Sublist.Sublist)
   }
 
   test("sublist in middle") {
+    pending
     Sublist.sublist(List(4, 3, 2), List(5, 4, 3, 2, 1)) should be (Sublist.Sublist)
   }
 
   test("sublist at end") {
+    pending
     Sublist.sublist(List(3, 4, 5), List(1, 2, 3, 4, 5)) should be (Sublist.Sublist)
   }
 
   test("partially matching sublist at start") {
+    pending
     Sublist.sublist(List(1, 1, 2), List(1, 1, 1, 2)) should be (Sublist.Sublist)
   }
 
   test("sublist early in huge list") {
+    pending
     val xs = List.range(1, 1000000)
     Sublist.sublist(List(3, 4, 5), xs) should be (Sublist.Sublist)
   }
 
   test("huge sublist not in huge list") {
+    pending
     val l1 = List.range(10, 1000001)
     val l2 = List.range(1, 1000000)
     Sublist.sublist(l1, l2) should be (Sublist.Unequal)
   }
 
   test("superlist at start") {
+    pending
     Sublist.sublist(List(1, 2, 3, 4, 5), List(1, 2, 3)) should be (Sublist.Superlist)
   }
 
   test("superlist in middle") {
+    pending
     Sublist.sublist(List(5, 4, 3, 2, 1), List(4, 3, 2)) should be (Sublist.Superlist)
   }
 
   test("superlist at end") {
+    pending
     Sublist.sublist(List(1, 2, 3, 4, 5), List(3, 4, 5)) should be (Sublist.Superlist)
   }
 
   test("partially matching superlist at start") {
+    pending
     Sublist.sublist(List(1, 1, 1, 2), List(1, 1, 2)) should be (Sublist.Superlist)
   }
 
   test("superlist early in huge list") {
+    pending
     val l1 = List.range(1, 1000000)
     Sublist.sublist(l1, List(3, 4, 5)) should be (Sublist.Superlist)
   }
 
   test("recurring values sublist") {
+    pending
     Sublist.sublist(List(1, 2, 1, 2, 3), List(1, 2, 3, 1, 2, 1, 2, 3, 2, 1)) should be (Sublist.Sublist)
   }
 
   test("recurring values unequal") {
+    pending
     Sublist.sublist(List(1, 2, 1, 2, 3), List(1, 2, 3, 1, 2, 3, 2, 3, 2, 1)) should be (Sublist.Unequal)
   }
 }

data/tracks/scala/exercises/trinary/src/test/scala/TrinaryTest.scala

@@ -7,7 +7,8 @@ class TrinaryTest extends FlatSpec with Matchers {
     }
   }
 
-  it should "invalid trinary should error" in {
+  it should "invalid trinary should error" in { 
+    pending
     intercept[IllegalArgumentException] {
       Trinary.trinaryToInt("1239")
     }
@@ -21,33 +22,39 @@ class TrinaryTest extends FlatSpec with Matchers {
     }
   }
 
-  it should "handle zeros" in {
+  it should "handle zeros" in { 
+    pending
     Trinary.trinaryToInt("0") should equal(0)
     Trinary.trinaryToInt("00000000") should equal(0)
   }
 
-  it should "handle single digit" in {
+  it should "handle single digit" in { 
+    pending
     Trinary.trinaryToInt("2") should equal(2)
   }
 
-  it should "handle multiple digits" in {
+  it should "handle multiple digits" in { 
+    pending
     Trinary.trinaryToInt("10") should equal(3)
     Trinary.trinaryToInt("12") should equal(5)
     Trinary.trinaryToInt("222") should equal(26)
     Trinary.trinaryToInt("1122000120") should equal(32091)
   }
 
-  it should "handle Int 0" in {
+  it should "handle Int 0" in { 
+    pending
     Trinary.intToTrinary(0) should equal("0")
   }
 
-  it should "handle Int to multi digit trinary" in {
+  it should "handle Int to multi digit trinary" in { 
+    pending
     Trinary.intToTrinary(4) should equal("11")
     Trinary.intToTrinary(26) should equal("222")
     Trinary.intToTrinary(32091) should equal("1122000120")
   }
 
-  it should "handle Int to trinary with trailing zeros" in {
+  it should "handle Int to trinary with trailing zeros" in { 
+    pending
     Trinary.intToTrinary(3) should equal("10")
   }
 }

data/tracks/scala/exercises/wordy/src/test/scala/WordProblemTest.scala

@@ -6,62 +6,76 @@ class WordProblemTest extends FlatSpec with Matchers {
     WordProblem("What is 1 plus 1?") should equal(Some(2))
   }
 
-  it should "handle addition with negative numbers" in {
+  it should "handle addition with negative numbers" in { 
+    pending
     WordProblem("What is -1 plus -10?") should equal(Some(-11))
   }
 
-  it should "handle repeated addition" in {
+  it should "handle repeated addition" in { 
+    pending
     WordProblem("What is 1 plus 1 plus 1?") should equal(Some(3))
   }
 
-  it should "handle simple subtraction" in {
+  it should "handle simple subtraction" in { 
+    pending
     WordProblem("What is 1 minus 1?") should equal(Some(0))
   }
 
-  it should "handle subtraction with negative numbers" in {
+  it should "handle subtraction with negative numbers" in { 
+    pending
     WordProblem("What is 4 minus -12?") should equal(Some(16))
   }
 
-  it should "handle repeated subtraction" in {
+  it should "handle repeated subtraction" in { 
+    pending
     WordProblem("What is 20 minus 4 minus 13?") should equal(Some(3))
   }
 
-  it should "handle simple multiplication" in {
+  it should "handle simple multiplication" in { 
+    pending
     WordProblem("What is 10 multiplied by 10?") should equal(Some(100))
   }
 
-  it should "handle multiplication with negative numbers" in {
+  it should "handle multiplication with negative numbers" in { 
+    pending
     WordProblem("What is -10 multiplied by -10?") should equal(Some(100))
   }
 
-  it should "handle repeated multiplication" in {
+  it should "handle repeated multiplication" in { 
+    pending
     WordProblem("What is 2 multiplied by -2 multiplied by 3?") should equal(Some(-12))
   }
 
-  it should "handle simple division" in {
+  it should "handle simple division" in { 
+    pending
     WordProblem("What is 10 divided by 10?") should equal(Some(1))
   }
 
-  it should "handle division with negative numbers" in {
+  it should "handle division with negative numbers" in { 
+    pending
     WordProblem("What is 33 divided by -3?") should equal(Some(-11))
   }
 
-  it should "handle repeated division" in {
+  it should "handle repeated division" in { 
+    pending
     WordProblem("What is -12 divided by 2 divided by -3?") should equal(Some(2))
   }
 
-  it should "handle mixed operations" in {
+  it should "handle mixed operations" in { 
+    pending
     WordProblem("What is 1 plus 5 minus -2?") should equal(Some(8))
     WordProblem("What is 17 minus 6 plus 3?") should equal(Some(14))
     WordProblem("What is -3 plus 7 multiplied by -2?") should equal(Some(-8))
   }
 
-  it should "handle invalid word problem" in {
+  it should "handle invalid word problem" in { 
+    pending
     WordProblem("What is 1 plus 5 minus -2?") should equal(Some(8))
   }
 
   // Test for "Extension"
-  ignore should "handle powers" in {
+  ignore should "handle powers" in { 
+    pending
     WordProblem("What is 2 raised to the 5?") should equal(Some(32))
   }
 }

data/tracks/scala/project/Build.scala

@@ -44,11 +44,11 @@ object XScalaBuild extends Build {
         throw new IllegalArgumentException(s"Could not parse $configJsonFile as JSON")
       }
     configObj
-      .get("problems")
+      .get("exercises")
       .map(_.asInstanceOf[JSONArray].list)
       .getOrElse {
-        throw new IllegalArgumentException(s"Could not find array 'problems' in $configJsonFile")
+        throw new IllegalArgumentException(s"Could not find array 'exercises' in $configJsonFile")
       }
-      .collect { case problem: String => problem }
+      .collect { case problem: JSONObject => problem.obj("slug").toString }
   }
 }

data/tracks/scala/testgen/src/main/scala/BowlingTestGenerator.scala

@@ -0,0 +1,57 @@
+import play.api.libs.json.Json
+
+import scala.io.Source
+
+class BowlingTestGenerator {
+  implicit val testCaseReader = Json.reads[BowlingTestCase]
+
+  private val filename = "bowling.json"
+  private val fileContents = Source.fromFile(filename).getLines.mkString
+  private val json = Json.parse(fileContents)
+
+  def write {
+    print("import org.scalatest.{FunSuite, Matchers}" + System.lineSeparator())
+    print(System.lineSeparator())
+    print("class BowlingSuite extends FunSuite with Matchers {" + System.lineSeparator())
+
+    writeTestCases()
+
+    print("}" + System.lineSeparator())
+  }
+
+  private def writeTestCases(): Unit = {
+    println("// " +  (json \ "score" \ "description").get.as[List[String]].mkString(" "))
+
+    val testCases = (json \ "score" \ "cases").get.as[List[BowlingTestCase]]
+
+    testCases.foreach(tc => {
+      print("\ttest(\"" + tc.description + "\") {" + System.lineSeparator())
+      println("pending")
+      print("val score = List(")
+      print(tc.rolls.map(roll => roll.toString).mkString(", "))
+      println(").foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()")
+
+      println("score match {")
+      if (tc.expected == -1) {
+        println("case Right(_) => fail(\"Unexpected score returned. Failure expected\")")
+        println("case Left(_) => ")
+      } else {
+        println("case Right(n) => assert(n == " + tc.expected.toString + ")")
+        println("case Left(_) => fail(\"" + tc.description + "\")")
+      }
+      println("}")
+      print("\t}" + System.lineSeparator())
+      print(System.lineSeparator())
+    })
+  }
+}
+
+case class BowlingTestCase(description: String,
+                           rolls: List[Int],
+                           expected: Int)
+
+object BowlingTestGenerator {
+  def main(args: Array[String]): Unit = {
+    new BowlingTestGenerator().write
+  }
+}

data/tracks/sml/config.json

@@ -5,12 +5,47 @@
   "checklist_issue": 8,
   "active": false,
   "test_pattern": "^test_*.sml$",
-  "problems": [
-    "accumulate",
-    "allergies",
-    "anagram",
-    "binary",
-    "hamming"
+  "exercises": [
+    {
+      "slug": "accumulate",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "allergies",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "anagram",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "binary",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "flatten-array",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "hamming",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "raindrops",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "nth-prime",
+      "difficulty": 1,
+      "topics": []
+    }
   ],
   "deprecated": [
 

data/tracks/sml/exercises/flatten-array/example.sml

@@ -0,0 +1,6 @@
+datatype 'a nestedList =
+	  Leaf of 'a			     (* leaf *)
+	| Node of 'a nestedList list (* node *)
+
+fun flatten (Leaf x)  = [x]
+  | flatten (Node xs) = List.concat (map flatten xs)

data/tracks/sml/exercises/flatten-array/test_flatten_array.sml

@@ -0,0 +1,10 @@
+use "example.sml";
+val test_cases = [
+    ((Node [Leaf 1, Node [Leaf 2, Node [], Leaf 3, Node [Leaf 4, Leaf 5]]]), [1,2,3,4,5])
+];
+
+fun run_tests [] = []
+  | run_tests ((input,expected)::ts) =
+       (flatten input = expected) :: run_tests ts
+
+val allTestsPass = List.foldl (fn (x,y) => x andalso y) true (run_tests test_cases);

data/tracks/sml/exercises/nth-prime/example.sml

@@ -0,0 +1,46 @@
+exception EmptyList
+datatype 'a lazylist = Nil | Cons of ('a * (unit -> 'a lazylist));
+fun next s = let
+    fun next' Nil = raise EmptyList
+      | next' (Cons(a,f)) = f()
+in
+    next' s
+end ;
+                 
+fun hd s = let
+    fun hd' Nil = raise EmptyList
+      | hd' (Cons(a, _)) = a
+in
+    hd' s
+end ;
+
+fun allPrimes n = let
+    fun isPrime n = let
+        fun factors n = let
+            fun factors' 0 acc = acc
+              | factors' c acc = if (n mod c) = 0
+                                 then factors' (c-1) (c :: acc)
+                                 else factors' (c-1) acc
+        in
+            factors' (n div 2) []
+        end
+    in
+        (List.length (factors n)) = 1
+    end
+                        
+    fun nextPrime n = let
+        val nextN = if (n mod 2) = 0 then n + 1 else n + 2
+    in
+        if isPrime nextN then nextN else nextPrime nextN
+    end
+                          
+in
+    Cons(n, fn () => (allPrimes (nextPrime n)))
+end ;
+                      
+fun nthPrime n = let
+    fun nthPrime' 0 s = hd s 
+      | nthPrime' n s = nthPrime' (n-1) (next s)
+in
+    nthPrime' (n-1) (allPrimes 2)
+end ;

data/tracks/sml/exercises/nth-prime/test_nth_prime.sml

@@ -0,0 +1,14 @@
+use "example.sml";
+
+val test_cases = [
+    (1, 2),
+    (2, 3),
+    (9, 23),
+    (100, 541)
+];
+
+fun run_tests [] = []
+  | run_tests ((n, expected)::ts) =
+       (nthPrime n = expected) :: run_tests ts
+                                                         
+val allTestsPass = List.foldl (fn (x,y) => x andalso y) true (run_tests test_cases);

data/tracks/sml/exercises/raindrops/example.sml

@@ -0,0 +1,9 @@
+fun convert (n: int): string =
+  let
+    fun f m s = if n mod m = 0 then s else ""
+    val sound = String.concat [f 3 "Pling", f 5 "Plang", f 7 "Plong"]
+  in
+    if sound = ""
+    then Int.toString n
+    else sound
+  end

data/tracks/sml/exercises/raindrops/raindrops.sml

@@ -0,0 +1,2 @@
+fun convert (n: int): string =
+  raise Fail "'convert' is not implemented"

data/tracks/sml/exercises/raindrops/test_raindrops.sml

@@ -0,0 +1,95 @@
+use "example.sml";
+
+val test_cases = [
+  {
+    number = 1,
+    expected = "1"
+  },
+  {
+    number = 3,
+    expected = "Pling"
+  },
+  {
+    number = 5,
+    expected = "Plang"
+  },
+  {
+    number = 7,
+    expected = "Plong"
+  },
+  {
+    number = 6,
+    expected = "Pling"
+  },
+  {
+    number = 8,
+    expected = "8"
+  },
+  {
+    number = 9,
+    expected = "Pling"
+  },
+  {
+    number = 10,
+    expected = "Plang"
+  },
+  {
+    number = 14,
+    expected = "Plong"
+  },
+  {
+    number = 15,
+    expected = "PlingPlang"
+  },
+  {
+    number = 21,
+    expected = "PlingPlong"
+  },
+  {
+    number = 25,
+    expected = "Plang"
+  },
+  {
+    number = 27,
+    expected = "Pling"
+  },
+  {
+    number = 35,
+    expected = "PlangPlong"
+  },
+  {
+    number = 49,
+    expected = "Plong"
+  },
+  {
+    number = 52,
+    expected = "52"
+  },
+  {
+    number = 105,
+    expected = "PlingPlangPlong"
+  },
+  {
+    number = 3125,
+    expected = "Plang"
+  }
+]
+
+fun run_tests _ [] = []
+  | run_tests f (x :: xs) =
+      let
+        fun aux { number, expected } =
+          let
+            val output = f number
+            val is_correct = output = expected
+            val expl =
+              "convert " ^ (Int.toString number) ^ ": " ^
+              (if not is_correct then "FAILED" else "PASSED") ^ "\n"
+          in
+            (print (expl); is_correct)
+          end
+      in
+        (aux x) :: run_tests f xs
+      end
+
+val allTestsPass = List.all (fn x => x) (run_tests convert test_cases)