trackler 2.2.1.36 → 2.2.1.37

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

@@ -0,0 +1,50 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder.{toString, _}
+import testgen._
+
+object PalindromeProductsTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/palindrome-products.json")
+
+    def toStringFromMap(m: Map[String, Any]): String =
+      s"Some((${m("value").toString}, " +
+        s"Set(${m("factors").asInstanceOf[List[List[Int]]].map(xs => "(" + xs.map(_.toString).mkString(", ") + ")").mkString(", ")})))"
+
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Left(_) => "None"
+        case Right(m: Map[String, any]) => toStringFromMap(m)
+      }
+    }
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgs(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val sutCall = s"""$sut($args).$property"""
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+    val code =
+      TestSuiteBuilder.build(file, fromLabeledTest("input_min", "input_max"),
+        Seq(),
+        Seq("// PalindromeProducts largest call is expecting a return type of",
+            "// Option[(Int, Set[(Int, Int)])] - None is expected for error cases.",
+            "// Some is expected for valid cases. The first element of the tuple ",
+            "// is the largest palindrome product value. The second element of the",
+            "// tuple is the list of factors.",
+            "// PalindromeProducts smallest call is expecting a return type of",
+            "// Option[(Int, Set[(Int, Int)])] - None is expected for error cases.",
+            "// Some is expected for valid cases. The first element of the tuple ",
+            "// is the smallest palindrome product value. The second element of the",
+            "// tuple is the list of factors."))
+
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

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

@@ -30,7 +30,6 @@ object CanonicalDataParser {
     val rawParseResult =
       JSON.parseFull(fileContents).get.asInstanceOf[ParseResult]
     val parseResult = rawParseResult mapValues restoreInts
-    println(parseResult)
     parseResult
   }
 
@@ -59,15 +58,17 @@ object Exercise {
     val cases: Cases =
       getRequired[Seq[ParseResult]](result, "cases") map LabeledTestItem.fromParseResult
     Exercise(getRequired(result, "exercise"), getRequired(result, "version"),
-        flattenCases(cases), getOptional(result, "comments"))
+        flattenCases(cases, List()), getOptional(result, "comments"))
   }
 
   // so far there are to few LabeledTestGroups to handle them separately
-  private def flattenCases(cases: Cases): Cases =
+  private def flattenCases(cases: Cases, parentDescriptions: List[String]): Cases =
     cases match {
       case Seq() => Seq()
-      case (ltg: LabeledTestGroup) +: xs => flattenCases(ltg.cases) ++ flattenCases(xs)
-      case (lt: LabeledTest) +: xs => lt +: flattenCases(xs)
+      case (ltg: LabeledTestGroup) +: xs => flattenCases(ltg.cases, ltg.description :: parentDescriptions) ++
+        flattenCases(xs, parentDescriptions)
+      case (lt: LabeledTest) +: xs => LabeledTest(lt.description, lt.property, lt.expected, lt.result, parentDescriptions) +:
+        flattenCases(xs, parentDescriptions)
     }
 }
 
@@ -79,7 +80,7 @@ object LabeledTestItem {
 }
 
 case class LabeledTest(description: Description, property: Property,
-    expected: Expected, result: ParseResult) extends LabeledTestItem
+    expected: Expected, result: ParseResult, parentDescriptions: List[String] = List()) extends LabeledTestItem
 object LabeledTest {
   implicit def fromParseResult(result: ParseResult): LabeledTest = {
     val expected: Expected = {

data/tracks/sml/config.json

@@ -214,6 +214,27 @@
 
       ]
     },
+    {
+      "uuid": "f923bffb-109f-4257-957c-cea8cae2d5c5",
+      "slug": "phone-number",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
+    {
+
+      "uuid": "b4359037-8457-49ea-ac33-44710ada3b4d",
+      "slug": "roman-numerals",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "225cfd7d-81a3-4a58-b1aa-1de2e40e7a93",
       "slug": "binary",

data/tracks/sml/exercises/phone-number/README.md

@@ -0,0 +1,64 @@
+# Phone Number
+
+Clean up user-entered phone numbers so that they can be sent SMS messages.
+
+The **North American Numbering Plan (NANP)** is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda. All NANP-countries share the same international country code: `1`.
+
+NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as *area code*, followed by a seven-digit local number. The first three digits of the local number represent the *exchange code*, followed by the unique four-digit number which is the *subscriber number*.
+
+
+The format is usually represented as
+```
+(NXX)-NXX-XXXX
+```
+where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
+
+Your task is to clean up differently formated telephone numbers by removing punctuation and the country code (1) if present.
+
+For example, the inputs
+- `+1 (613)-995-0253`
+- `613-995-0253`
+- `1 613 995 0253`
+- `613.995.0253`
+
+should all produce the output
+
+`6139950253`
+
+**Note:** As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.
+
+## Loading your exercise implementation in PolyML
+
+```
+$ poly --use {exercise}.sml
+```
+
+Or:
+
+```
+$ poly
+> use "{exercise}.sml";
+```
+
+**Note:** You have to replace {exercise}.
+
+## Running the tests
+
+```
+$ poly -q --use test.sml
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/sml](https://github.com/exercism/sml) repository on
+GitHub is the home for all of the Standard ML exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue. We'll do our best to help you!
+
+## Source
+
+Event Manager by JumpstartLab [http://tutorials.jumpstartlab.com/projects/eventmanager.html](http://tutorials.jumpstartlab.com/projects/eventmanager.html)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/sml/exercises/phone-number/example.sml

@@ -0,0 +1,18 @@
+fun clean text =
+  let
+    fun valid (#"0" :: _) = false
+      | valid (#"1" :: _) = false
+      | valid digits      = List.nth (digits, 3) > #"1"
+        
+    fun check digits =
+      case length digits of
+        10 => if valid digits
+              then SOME (implode digits)
+              else NONE
+      | 11 => if hd digits = #"1"
+              then check (tl digits)
+              else NONE
+      | _  => NONE
+  in
+    check (List.filter Char.isDigit (explode text))
+  end

data/tracks/sml/exercises/phone-number/phone-number.sml

@@ -0,0 +1,2 @@
+fun clean (text: string): string option =
+  raise Fail "'clean' is not implemented"

data/tracks/sml/exercises/phone-number/test.sml

@@ -0,0 +1,50 @@
+(* version 1.2.0 *)
+
+use "testlib.sml";
+use "phone-number.sml";
+
+infixr |>
+fun x |> f = f x
+
+val testsuite =
+  describe "phone-number" [
+    describe "Cleanup user-entered phone numbers" [
+      test "cleans the number"
+        (fn _ => clean ("(223) 456-7890") |> Expect.equalTo (SOME "2234567890")),
+
+      test "cleans numbers with dots"
+        (fn _ => clean ("223.456.7890") |> Expect.equalTo (SOME "2234567890")),
+
+      test "cleans numbers with multiple spaces"
+        (fn _ => clean ("223 456   7890   ") |> Expect.equalTo (SOME "2234567890")),
+
+      test "invalid when 9 digits"
+        (fn _ => clean ("123456789") |> Expect.equalTo NONE),
+
+      test "invalid when 11 digits does not start with a 1"
+        (fn _ => clean ("22234567890") |> Expect.equalTo NONE),
+
+      test "valid when 11 digits and starting with 1"
+        (fn _ => clean ("12234567890") |> Expect.equalTo (SOME "2234567890")),
+
+      test "valid when 11 digits and starting with 1 even with punctuation"
+        (fn _ => clean ("+1 (223) 456-7890") |> Expect.equalTo (SOME "2234567890")),
+
+      test "invalid when more than 11 digits"
+        (fn _ => clean ("321234567890") |> Expect.equalTo NONE),
+
+      test "invalid with letters"
+        (fn _ => clean ("123-abc-7890") |> Expect.equalTo NONE),
+
+      test "invalid with punctuations"
+        (fn _ => clean ("123-@:!-7890") |> Expect.equalTo NONE),
+
+      test "invalid if area code does not start with 2-9"
+        (fn _ => clean ("(123) 456-7890") |> Expect.equalTo NONE),
+
+      test "invalid if exchange code does not start with 2-9"
+        (fn _ => clean ("(223) 056-7890") |> Expect.equalTo NONE)
+    ]
+  ]
+
+val _ = Test.run testsuite

data/tracks/sml/exercises/phone-number/testlib.sml

@@ -0,0 +1,159 @@
+structure Expect =
+struct
+  datatype expectation = Pass | Fail of string * string
+
+  local
+    fun failEq b a =
+      Fail ("Expected: " ^ b, "Got: " ^ a)
+    
+    fun failExn b a =
+      Fail ("Expected: " ^ b, "Raised: " ^ a)
+
+    fun exnName (e: exn): string = General.exnName e
+  in
+    fun truthy a =
+      if a
+      then Pass
+      else failEq "true" "false"
+
+    fun falsy a =
+      if a
+      then failEq "false" "true"
+      else Pass
+
+    fun equalTo b a = 
+      if a = b
+      then Pass
+      else failEq (PolyML.makestring b) (PolyML.makestring a)
+
+    fun nearTo b a =
+      if Real.== (a, b)
+      then Pass
+      else failEq (Real.toString b) (Real.toString a)
+
+    fun anyError f =
+      (
+        f ();
+        failExn "an exception" "Nothing"
+      ) handle _ => Pass
+
+    fun error e f =
+      (
+        f ();
+        failExn (exnName e) "Nothing"
+      ) handle e' => if exnMessage e' = exnMessage e
+                     then Pass
+                     else failExn (exnMessage e) (exnMessage e')
+  end
+end
+
+structure TermColor =
+struct
+  datatype color = Red | Green | Yellow | Normal
+
+  fun f Red    = "\027[31m"
+    | f Green  = "\027[32m"
+    | f Yellow = "\027[33m"
+    | f Normal = "\027[0m"
+
+  fun colorize color s = (f color) ^ s ^ (f Normal)
+
+  val redit = colorize Red
+
+  val greenit = colorize Green
+
+  val yellowit = colorize Yellow
+end
+
+structure Test =
+struct
+  datatype testnode = TestGroup of string * testnode list
+                    | Test of string * (unit -> Expect.expectation)
+
+  local
+    datatype evaluation = Success of string
+                        | Failure of string * string * string
+                        | Error of string * string
+
+    fun indent n s = (implode (List.tabulate (n, fn _ => #" "))) ^ s
+
+    fun fmt indentlvl ev =
+      let
+        val check = TermColor.greenit "\226\156\148 " (* ✔ *)
+        val cross = TermColor.redit "\226\156\150 "   (* ✖ *)
+        val indentlvl = indentlvl * 2
+      in
+      case ev of
+        Success descr => indent indentlvl (check ^ descr)
+      | Failure (descr, exp, got) =>
+          String.concatWith "\n" [indent indentlvl (cross ^ descr),
+                                  indent (indentlvl + 2) exp,
+                                  indent (indentlvl + 2) got]
+      | Error (descr, reason) =>
+          String.concatWith "\n" [indent indentlvl (cross ^ descr),
+                                  indent (indentlvl + 2) (TermColor.redit reason)]
+      end
+
+    fun eval (TestGroup _) = raise Fail "Only a 'Test' can be evaluated"
+      | eval (Test (descr, thunk)) =
+          (
+            case thunk () of
+              Expect.Pass   => ((1, 0, 0), Success descr)
+            | Expect.Fail (s, s') => ((0, 1, 0), Failure (descr, s, s'))
+          )
+          handle e => ((0, 0, 1), Error (descr, "Unexpected error: " ^ exnMessage e))
+
+    fun flatten depth testnode =
+      let
+        fun sum (x, y, z) (a, b, c) = (x + a, y + b, z + c)
+
+        fun aux (t, (counter, acc)) =
+          let
+            val (counter', texts) = flatten (depth + 1) t
+          in
+            (sum counter' counter, texts :: acc)
+          end
+      in
+        case testnode of
+          TestGroup (descr, ts) =>
+            let
+              val (counter, texts) = foldr aux ((0, 0, 0), []) ts
+            in
+              (counter, (indent (depth * 2) descr) :: List.concat texts)
+            end
+        | Test _ =>
+            let
+              val (counter, evaluation) = eval testnode
+            in
+              (counter, [fmt depth evaluation])
+            end
+      end
+    
+    fun println s = print (s ^ "\n")
+  in
+    fun run suite =
+      let
+        val ((succeeded, failed, errored), texts) = flatten 0 suite
+
+        val summary = String.concatWith ", " [
+          TermColor.greenit ((Int.toString succeeded) ^ " passed"),
+          TermColor.redit ((Int.toString failed) ^ " failed"),
+          TermColor.redit ((Int.toString errored) ^ " errored"),
+          (Int.toString (succeeded + failed + errored)) ^ " total"
+        ]
+        
+        val status = if failed = 0 andalso errored = 0
+                     then OS.Process.success
+                     else OS.Process.failure
+
+      in
+        List.app println texts;
+        println "";
+        println ("Tests: " ^ summary);
+        OS.Process.exit status
+      end
+  end
+end
+
+fun describe description tests = Test.TestGroup (description, tests)
+fun test description thunk = Test.Test (description, thunk)

data/tracks/sml/exercises/roman-numerals/README.md

@@ -0,0 +1,79 @@
+# Roman Numerals
+
+Write a function to convert from normal numbers to Roman Numerals.
+
+The Romans were a clever bunch. They conquered most of Europe and ruled
+it for hundreds of years. They invented concrete and straight roads and
+even bikinis. One thing they never discovered though was the number
+zero. This made writing and dating extensive histories of their exploits
+slightly more challenging, but the system of numbers they came up with
+is still in use today. For example the BBC uses Roman numerals to date
+their programmes.
+
+The Romans wrote numbers using letters - I, V, X, L, C, D, M. (notice
+these letters have lots of straight lines and are hence easy to hack
+into stone tablets).
+
+```
+ 1  => I
+10  => X
+ 7  => VII
+```
+
+There is no need to be able to convert numbers larger than about 3000.
+(The Romans themselves didn't tend to go any higher)
+
+Wikipedia says: Modern Roman numerals ... are written by expressing each
+digit separately starting with the left most digit and skipping any
+digit with a value of zero.
+
+To see this in practice, consider the example of 1990.
+
+In Roman numerals 1990 is MCMXC:
+
+1000=M
+900=CM
+90=XC
+
+2008 is written as MMVIII:
+
+2000=MM
+8=VIII
+
+See also: http://www.novaroma.org/via_romana/numbers.html
+
+## Loading your exercise implementation in PolyML
+
+```
+$ poly --use {exercise}.sml
+```
+
+Or:
+
+```
+$ poly
+> use "{exercise}.sml";
+```
+
+**Note:** You have to replace {exercise}.
+
+## Running the tests
+
+```
+$ poly -q --use test.sml
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/sml](https://github.com/exercism/sml) repository on
+GitHub is the home for all of the Standard ML exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue. We'll do our best to help you!
+
+## Source
+
+The Roman Numeral Kata [http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals](http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.