trackler 2.0.6.40 → 2.0.6.41

data/tracks/scala/exercises/binary-search/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/binary-search/example.scala

@@ -0,0 +1,23 @@
+import scala.annotation.tailrec
+
+object BinarySearch {
+  def search[T](seq: Seq[T], value: T)(implicit ord: T => Ordered[T]): Option[Int]
+    = searchInternal(seq, value, 0, seq.size - 1)
+
+  @tailrec
+  def searchInternal[T](seq: Seq[T], value: T,
+                        start: Int, end: Int)(implicit ord: T => Ordered[T]): Option[Int] = {
+    if (end < start || start < 0)
+      None
+    else {
+      val middle = Math.floor(0.5 * (start + end)).asInstanceOf[Int]
+      val elem = seq(middle)
+      if (elem == value)
+        Some(middle)
+      else if (value < elem)
+        searchInternal(seq, value, start, middle - 1)
+      else
+        searchInternal(seq, value, middle + 1, end)
+    }
+  }
+}

data/tracks/scala/exercises/binary-search/src/test/scala/BinarySearchTest.scala

@@ -0,0 +1,63 @@
+import org.scalatest.{FunSuite, Matchers}
+
+class BinarySearchTest extends FunSuite with Matchers {
+
+  test("finds a value in an array with one element") {
+    val result = BinarySearch.search(Array(6), 6)
+    result should be (Some(0))
+  }
+
+  test("finds a value in the middle of an array") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 4, 6, 8, 9, 11), 6)
+    result should be (Some(3))
+  }
+
+  test("finds a value at the beginning of an array") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 4, 6, 8, 9, 11), 1)
+    result should be (Some(0))
+  }
+
+  test("finds a value at the end of an array") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 4, 6, 8, 9, 11), 11)
+    result should be (Some(6))
+  }
+
+  test("finds a value in an array of odd length") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634), 144)
+    result should be (Some(9))
+  }
+
+  test("finds a value in an array of even length") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377), 21)
+    result should be (Some(5))
+  }
+
+  test("identifies that a value is not included in the array") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 4, 6, 8, 9, 11), 7)
+    result should be (None)
+  }
+
+  test("a value smaller than the array's smallest value is not included") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 4, 6, 8, 9, 11), 0)
+    result should be (None)
+  }
+
+  test("a value larger than the array's largest value is not included") {
+    pending
+    val result = BinarySearch.search(Array(1, 3, 4, 6, 8, 9, 11), 13)
+    result should be (None)
+  }
+
+  test("nothing is included in an empty array") {
+    pending
+    val result = BinarySearch.search(Array[Int](), 1)
+    result should be (None)
+  }
+}

data/tracks/scala/exercises/strain/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/strain/example.scala

@@ -0,0 +1,22 @@
+import scala.annotation.tailrec
+
+object Strain {
+  def keep[A](seq: Seq[A], func: A => Boolean): Seq[A] =
+    recurse(seq, func, List()).reverse
+
+  def discard[A](seq: Seq[A], func: A => Boolean): Seq[A] = {
+    val notFunc: A => Boolean = a => !func(a)
+    recurse(seq, notFunc, List()).reverse
+  }
+
+  @tailrec
+  private def recurse[A](seq: Seq[A], func: A => Boolean, acc: Seq[A]): Seq[A] =
+    seq match {
+      case Nil => acc
+      case x::xs =>
+        if (func(x))
+          recurse(xs, func, x +: acc)
+        else
+          recurse(xs, func, acc)
+    }
+}

data/tracks/scala/exercises/strain/src/test/scala/StrainTest.scala

@@ -0,0 +1,78 @@
+import org.scalatest.{Matchers, FlatSpec}
+
+class StrainTest extends FlatSpec with Matchers {
+
+  it should "handle empty keep" in {
+    val result = Strain.keep[Int](List(), x => x < 10)
+    result should be(List.empty)
+  }
+
+  it should "keep everything" in {
+    pending
+    val expectedList = List("a", "b", "c")
+    val result = Strain.keep[String](expectedList, _ => true)
+    result should be(expectedList)
+  }
+
+  it should "keep first and last" in {
+    pending
+    val result = Strain.keep[Int](List(1, 2, 3), x => x % 2 != 0)
+    result should be(List(1, 3))
+  }
+
+  it should "keep neither first or last" in {
+    pending
+    val result = Strain.keep[Int](List(1, 2, 3, 4, 5), x => x % 2 == 0)
+    result should be(List(2, 4))
+  }
+
+  it should "keep strings" in {
+    pending
+    val words = List("apple",  "zebra", "banana", "zombies", "cherimoya",  "zelot")
+    val result = Strain.keep[String](words, s => s.startsWith("z"))
+    result should be(List("zebra", "zombies", "zelot"))
+  }
+
+  it should "keep sequences" in {
+    pending
+    val sequences = Seq(Seq(1, 2, 3), Seq(5, 5, 5), Seq(5, 1, 2), Seq(2, 1, 2),
+      Seq(1, 5, 2), Seq(2, 2, 1), Seq(1, 2, 5))
+    val expected = Seq(Seq(5, 5, 5), Seq(5, 1, 2), Seq(1, 5, 2), Seq(1, 2, 5))
+    val result = Strain.keep[Seq[Int]](sequences, seq => seq.contains(5))
+    result should be (expected)
+  }
+
+  it should "handle empty discard" in {
+    pending
+    val result = Strain.discard[Int](List(), x => x < 10)
+    result should be (List.empty)
+  }
+
+  it should "discard first and last" in {
+    pending
+    val result = Strain.discard[Int](List(1, 2, 3), x => x % 2 != 0)
+    result should be (List(2))
+  }
+
+  it should "discard neither first or last" in {
+    pending
+    val result = Strain.discard[Int](List(1, 2, 3, 4, 5), x => x % 2 == 0)
+    result should be (List(1, 3, 5))
+  }
+
+  it should "discard strings" in {
+    pending
+    val words = List("apple",  "zebra", "banana", "zombies", "cherimoya",  "zelot")
+    val result = Strain.discard[String](words, s => s.startsWith("z"))
+    result should be (List("apple", "banana", "cherimoya"))
+  }
+
+  it should "discard sequences" in {
+    pending
+    val sequences = Seq(Seq(1, 2, 3), Seq(5, 5, 5), Seq(5, 1, 2), Seq(2, 1, 2),
+      Seq(1, 5, 2), Seq(2, 2, 1), Seq(1, 2, 5))
+    val expected = Seq(Seq(1, 2, 3), Seq(2, 1, 2), Seq(2, 2, 1))
+    val result = Strain.discard[Seq[Int]](sequences, seq => seq.contains(5))
+    result should be (expected)
+  }
+}

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

@@ -2,35 +2,28 @@ import play.api.libs.json.Json
 
 import scala.io.Source
 
+
 class AllYourBaseTestGenerator {
-  implicit val testCaseReader = Json.reads[TestCase]
+  implicit val testCaseReader = Json.reads[AllYourBaseTestCase]
 
   private val filename = "all-your-base.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 AllYourBaseTest extends FunSuite with Matchers {" + System.lineSeparator())
-
-    writeTestCases()
+    val testCases: List[AllYourBaseTestCase] = (json \ "cases").get.as[List[AllYourBaseTestCase]]
 
-    print("}" + System.lineSeparator())
-  }
+    implicit def testCaseToGen(tc: AllYourBaseTestCase): TestCaseGen = {
+      val callSUT =
+        s"AllYourBase.rebase(${tc.input_base}, ${toListString(tc.input_digits)}, ${tc.output_base})"
+      val expected = toListString(tc.output_digits)
 
-  private def writeTestCases(): Unit = {
-    val testCases = (json \ "cases").get.as[List[TestCase]]
-
-    testCases.foreach(tc => {
-      print("\ttest(\"" + tc.description + "\") {" + System.lineSeparator())
-      println("pending")
-      println("AllYourBase.rebase(" + tc.input_base  + ", " + toListString(tc.input_digits) +
-        "," + System.lineSeparator() + tc.output_base + ") should be (" + toListString(tc.output_digits) + ")")
+      TestCaseGen(tc.description, callSUT, expected)
+    }
 
-      print("\t}" + System.lineSeparator())
-      print(System.lineSeparator())
-    })
+    val testBuilder = new TestBuilder("AllYourBaseTest")
+    testBuilder.addTestCases(testCases)
+    testBuilder.toFile
   }
 
   private def toListString(a: Array[Int]): String =
@@ -44,7 +37,7 @@ class AllYourBaseTestGenerator {
   }
 }
 
-case class TestCase(description: String,
+case class AllYourBaseTestCase(description: String,
                     input_base: Int, input_digits: Array[Int],
                     output_base: Int, output_digits: Option[Array[Int]])
 

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

@@ -0,0 +1,48 @@
+import play.api.libs.json.Json
+
+import scala.io.Source
+
+class BinarySearchTestGenerator {
+  implicit val testCaseReader = Json.reads[BinarySearchTestCase]
+
+  private val filename = "binarysearch.json"
+  private val fileContents = Source.fromFile(filename).getLines.mkString
+  private val json = Json.parse(fileContents)
+
+  def write {
+    val testCases = (json \ "cases").get.as[List[BinarySearchTestCase]]
+
+    implicit def testCaseToGen(tc: BinarySearchTestCase): TestCaseGen = {
+      val elements = tc.array.map(elem => elem.toString).mkString(", ")
+      val elementStr =
+        if (elements.isEmpty)
+          "Array[Int]()"
+        else
+          s"Array(${elements})"
+
+      val callSUT =
+        s"BinarySearch.search(${elementStr}, ${tc.value})"
+      val expected =
+        if (tc.expected == -1)
+          "None"
+        else
+          s"Some(${tc.expected})"
+
+      TestCaseGen(tc.description, callSUT, expected)
+    }
+
+    val testBuilder = new TestBuilder("BinarySearchTest")
+    testBuilder.addTestCases(testCases)
+    testBuilder.toFile
+  }
+}
+
+case class BinarySearchTestCase(description: String,
+                                array: Array[Int],
+                                value: Int, expected: Int)
+
+object BinarySearchTestGenerator {
+  def main(args: Array[String]): Unit = {
+    new BinarySearchTestGenerator().write
+  }
+}

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

@@ -10,39 +10,31 @@ class BowlingTestGenerator {
   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())
-    })
+    val description = (json \ "score" \ "description").get.as[List[String]].mkString(" ")
+
+    implicit def testCaseToGen(tc: BowlingTestCase): TestCaseGen = {
+      val callSUT =
+        s"${tc.rolls}.foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()"
+      val expected = ""
+      val result = s"val score = $callSUT"
+      val (matchRight, matchLeft) =
+        if (tc.expected == -1)
+          ("""fail("Unexpected score returned. Failure expected")""", "")
+        else
+          (s"assert(n == ${tc.expected})", s"""fail("${tc.description}")""")
+      val checkResult =
+s"""score match {
+      case Right(n) => $matchRight
+      case Left(_) => $matchLeft
+    }"""
+
+      TestCaseGen(tc.description, callSUT, expected, result, checkResult)
+    }
+
+    val testBuilder = new TestBuilder("BowlingTest")
+    testBuilder.addTestCases(testCases, Some(description))
+    testBuilder.toFile
   }
 }