trackler 2.1.0.26 → 2.1.0.27

data/tracks/kotlin/exercises/collatz-conjecture/src/example/kotlin/CollatzCalculator.kt

@@ -0,0 +1,12 @@
+object CollatzCalculator {
+
+    fun computeStepCount(start: Int): Int {
+        require(start > 0) { "Only natural numbers are allowed" }
+
+        if (start == 1) return 0
+
+        val next = if (start % 2 == 0) start / 2 else 3 * start + 1
+        return 1 + computeStepCount(next)
+    }
+
+}

data/tracks/kotlin/exercises/collatz-conjecture/src/test/kotlin/CollatzCalculatorTest.kt

@@ -0,0 +1,51 @@
+import org.junit.Ignore
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.0
+ */
+class CollatzCalculatorTest {
+
+    @Rule
+    @JvmField
+    var expectedException: ExpectedException = ExpectedException.none()
+
+    @Test
+    fun testZeroStepsRequiredWhenStartingFrom1() {
+        assertEquals(0, CollatzCalculator.computeStepCount(1))
+    }
+
+    @Ignore
+    @Test
+    fun testCorrectNumberOfStepsWhenAllStepsAreDivisions() {
+        assertEquals(4, CollatzCalculator.computeStepCount(16))
+    }
+
+    @Ignore
+    @Test
+    fun testCorrectNumberOfStepsWhenBothStepTypesAreNeeded() {
+        assertEquals(9, CollatzCalculator.computeStepCount(12))
+    }
+
+    @Ignore
+    @Test
+    fun testZeroIsConsideredInvalidInput() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Only natural numbers are allowed")
+
+        CollatzCalculator.computeStepCount(0)
+    }
+
+    @Ignore
+    @Test
+    fun testNegativeIntegerIsConsideredInvalidInput() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Only natural numbers are allowed")
+
+        CollatzCalculator.computeStepCount(-15)
+    }
+
+}

data/tracks/kotlin/exercises/diamond/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/kotlin/exercises/diamond/src/example/kotlin/DiamondPrinter.kt

@@ -0,0 +1,35 @@
+import java.util.*
+
+class DiamondPrinter {
+
+    companion object {
+        private val A_INT = 'A'.toInt()
+
+        private fun blank(length: Int): String {
+            return Collections.nCopies(length, " ").joinToString("")
+        }
+    }
+
+    fun printToList(chr: Char): List<String> {
+        val nRows = 2 * (chr.toInt() - A_INT) + 1
+
+        val result = mutableListOf<String>()
+
+        // Populate the top rows.
+        for (nRow in 0..(nRows + 1) / 2 - 1) {
+            val rowChr = (A_INT + nRow).toChar()
+
+            val leftHalfOfRow = blank((nRows - 1) / 2 - nRow) + rowChr + blank(nRow)
+            val rightHalfOfRow = leftHalfOfRow.reversed().drop(1)
+            val fullRow = "$leftHalfOfRow$rightHalfOfRow"
+
+            result.add(fullRow)
+        }
+
+        // Populate the bottom rows by 'reflecting' all rows above the middle row.
+        result.addAll(result.reversed().drop(1))
+
+        return result
+    }
+
+}

data/tracks/kotlin/exercises/diamond/src/main/kotlin/DiamondPrinter.kt

@@ -0,0 +1,5 @@
+class DiamondPrinter {
+
+
+
+}

data/tracks/kotlin/exercises/diamond/src/test/kotlin/DiamondPrinterTest.kt

@@ -0,0 +1,121 @@
+import org.hamcrest.CoreMatchers.`is`
+import org.junit.Assert.assertThat
+import org.junit.Before
+import org.junit.Ignore
+import org.junit.Test
+
+/*
+ * version: 1.0.0
+ */
+class DiamondPrinterTest {
+
+    private lateinit var diamondPrinter: DiamondPrinter
+
+    @Before
+    fun setUp() {
+        diamondPrinter = DiamondPrinter()
+    }
+
+    @Test
+    fun testOneByOneDiamond() {
+        val output = diamondPrinter.printToList('A')
+        assertThat(output, `is`(listOf("A")))
+    }
+
+    @Ignore
+    @Test
+    fun testTwoByTwoDiamond() {
+        val output = diamondPrinter.printToList('B')
+        assertThat(output, `is`(listOf(
+                " A ",
+                "B B",
+                " A ")))
+    }
+
+    @Ignore
+    @Test
+    fun testThreeByThreeDiamond() {
+        val output = diamondPrinter.printToList('C')
+        assertThat(output, `is`(listOf(
+                "  A  ",
+                " B B ",
+                "C   C",
+                " B B ",
+                "  A  ")))
+    }
+
+    @Ignore
+    @Test
+    fun testFiveByFiveDiamond() {
+        val output = diamondPrinter.printToList('E')
+        assertThat(output, `is`(listOf(
+                "    A    ",
+                "   B B   ",
+                "  C   C  ",
+                " D     D ",
+                "E       E",
+                " D     D ",
+                "  C   C  ",
+                "   B B   ",
+                "    A    ")))
+    }
+
+    @Ignore
+    @Test
+    fun testFullDiamond() {
+        val output = diamondPrinter.printToList('Z')
+        assertThat(output, `is`(listOf(
+                "                         A                         ",
+                "                        B B                        ",
+                "                       C   C                       ",
+                "                      D     D                      ",
+                "                     E       E                     ",
+                "                    F         F                    ",
+                "                   G           G                   ",
+                "                  H             H                  ",
+                "                 I               I                 ",
+                "                J                 J                ",
+                "               K                   K               ",
+                "              L                     L              ",
+                "             M                       M             ",
+                "            N                         N            ",
+                "           O                           O           ",
+                "          P                             P          ",
+                "         Q                               Q         ",
+                "        R                                 R        ",
+                "       S                                   S       ",
+                "      T                                     T      ",
+                "     U                                       U     ",
+                "    V                                         V    ",
+                "   W                                           W   ",
+                "  X                                             X  ",
+                " Y                                               Y ",
+                "Z                                                 Z",
+                " Y                                               Y ",
+                "  X                                             X  ",
+                "   W                                           W   ",
+                "    V                                         V    ",
+                "     U                                       U     ",
+                "      T                                     T      ",
+                "       S                                   S       ",
+                "        R                                 R        ",
+                "         Q                               Q         ",
+                "          P                             P          ",
+                "           O                           O           ",
+                "            N                         N            ",
+                "             M                       M             ",
+                "              L                     L              ",
+                "               K                   K               ",
+                "                J                 J                ",
+                "                 I               I                 ",
+                "                  H             H                  ",
+                "                   G           G                   ",
+                "                    F         F                    ",
+                "                     E       E                     ",
+                "                      D     D                      ",
+                "                       C   C                       ",
+                "                        B B                        ",
+                "                         A                         ")))
+    }
+
+}

data/tracks/kotlin/exercises/settings.gradle

@@ -46,3 +46,5 @@ include 'binary-search'
 include 'triangle'
 include 'bank-account'
 include 'sum-of-multiples'
+include 'diamond'
+include 'collatz-conjecture'

data/tracks/ocaml/.gitignore

@@ -7,3 +7,4 @@ tmp
 _build/
 bin/configlet
 bin/configlet.exe
+.psc-ide-port

data/tracks/ocaml/.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "OCaml",
+      "type": "ocamldebug",
+      "request": "launch",
+      "program": "${workspaceRoot}/tools/test-generator/test_gen.byte",
+      "console": "internalConsole",
+      "stopOnEntry": false,
+      "args": ["-l", "purescript" ,"-o", "/home/steve/dev/exercism/xpurescript/exercises"]
+    }
+  ]
+}

data/tracks/ocaml/tools/test-generator/src/controller.ml

@@ -6,6 +6,7 @@ open Codegen
 open Special_cases
 open Template
 open Files
+open Languages
 
 type content = string
 
@@ -15,8 +16,8 @@ let find_nested_files (name: string) (base: string): (string * content) list =
   |> List.filter ~f:(fun slug -> Sys.file_exists_exn (base ^ "/" ^ slug ^ "/" ^ name))
   |> List.map ~f:(fun slug -> (slug, In_channel.read_all (base ^ "/" ^ slug ^ "/" ^ name)))
 
-let find_template_files base filter = 
-  let all_files = find_nested_files "template.ml" base in
+let find_template_files base filter template_filename = 
+  let all_files = find_nested_files template_filename base in
   let filter = Option.value filter ~default:"" in
   List.filter all_files ~f:(fun (slug,_) -> String.is_substring slug ~substring:filter)
 
@@ -32,18 +33,19 @@ let simplify_single_test_suite (canonical_data: canonical_data): canonical_data
 | _ -> canonical_data
 
 
-let prepend_version (v: string option) (str: string): string = match v with
+let prepend_version (version_printer: string -> string) (v: string option) (str: string): string = match v with
 | None -> str
-| Some v -> "(* Test/exercise version: \"" ^ v ^ "\" *)\n\n" ^ str
+| Some v -> (version_printer v) ^ str
 
-let generate_code ~(slug: string) ~(template_file: content) ~(canonical_data_file: content): (content, string) Result.t =
+let generate_code ~(lc: language_config) ~(slug: string) ~(template_file: content) ~(canonical_data_file: content): (content, string) Result.t =
   let open Result.Monad_infix in
-  Result.of_option ~error:("cannot recognize file for " ^ slug ^ " as a template") @@ find_template template_file >>= fun template ->
-  let edit_expected = edit_expected ~stringify:json_to_string ~slug in
+  Result.of_option ~error:("cannot recognize file for " ^ slug ^ " as a template") @@ find_template template_file lc.test_start_marker lc.test_end_marker >>= fun template ->
+  let edit_expected = edit_expected ~language:lc.name ~stringify:json_to_string ~slug in
   let edit_parameters = edit_parameters ~slug in
   let fill_in_template = fill_in_template edit_expected edit_parameters in
   let file_text = template.file_text in
   let file_lines = String.split_lines file_text |> List.to_array in
+  let prepend_version = prepend_version lc.version_printer in
   parse_json_text canonical_data_file (expected_key_name slug) (cases_name slug)
   |> Result.map_error ~f:show_error >>| simplify_single_test_suite >>= fun cd -> (match cd.tests with
       | Single cases ->
@@ -65,10 +67,10 @@ let generate_code ~(slug: string) ~(template_file: content) ~(canonical_data_fil
         |> Result.map ~f:(prepend_version cd.version)
     )
 
-let output_tests (files: (string * content * content) list) (output_folder: string) ~(generated_folder: string): unit =
-  let output_filepath name = output_folder ^ "/" ^ name ^ "/test.ml" in
+let output_tests (lc: language_config) (files: (string * content * content) list) (output_folder: string) ~(generated_folder: string): unit =
+  let output_filepath name = output_folder ^ "/" ^ name ^ "/" ^ lc.template_file_name in
   let output1 (slug,t,c) =
-    match generate_code slug t c with
+    match generate_code lc slug t c with
     | Ok code -> 
         if backup ~base_folder:generated_folder ~slug ~contents:code
         then Out_channel.write_all (output_filepath slug) code
@@ -76,14 +78,11 @@ let output_tests (files: (string * content * content) list) (output_folder: stri
     | Error e -> print_endline ("Failed when generating " ^ slug ^ ", error: " ^ e) in
   List.iter files ~f:output1
 
-(*let add_header (canonical_data_folder: string) (generated: string): string =*)
-
-
-let run ~(templates_folder: string) ~(canonical_data_folder: string) ~(output_folder: string) ~(generated_folder: string) (filter: string option) =
-  let template_files = find_template_files templates_folder filter in
+let run ~(language_config: language_config) ~(templates_folder: string) ~(canonical_data_folder: string) ~(output_folder: string) ~(generated_folder: string) (filter: string option) =
+  let template_files = find_template_files templates_folder filter language_config.template_file_name in
   let canonical_data_files = find_canonical_data_files canonical_data_folder in
   let combined = combine_files template_files canonical_data_files in
-  output_tests combined output_folder generated_folder
+  output_tests language_config combined output_folder generated_folder
 
 let check_canonical_data canonical_data_folder =
   let ok_count = ref 0 in

data/tracks/ocaml/tools/test-generator/src/languages.ml

@@ -0,0 +1,30 @@
+open Core
+
+type language_config = {
+  name: string;
+  template_file_name: string;
+  default_base_folder: string;
+  test_start_marker: string;
+  test_end_marker: string;
+  version_printer: string -> string
+}
+
+let default_language_config = function
+| "ocaml" -> {
+    name = "ocaml";
+    template_file_name = "template.ml"; 
+    default_base_folder = "../..";
+    test_start_marker = "(* TEST"; 
+    test_end_marker = "END TEST";
+    version_printer = fun v -> "(* Test/exercise version: \"" ^ v ^ "\" *)\n\n";
+    }
+| "purescript" ->  {
+    name = "purescript";
+    template_file_name = "Main.purs"; 
+    default_base_folder = "../../../xpurescript";
+    test_start_marker = "--TEST"; 
+    test_end_marker = "--END TEST";
+    version_printer = fun v -> "-- Test/exercise version: \"" ^ v ^ "\"\n\n";
+    }
+| x -> failwith @@ "unknown language " ^ x
+

data/tracks/ocaml/tools/test-generator/src/ocaml_special_cases.ml

@@ -0,0 +1,137 @@
+open Core
+
+open Model
+open Yojson.Basic
+
+let strip_quotes s = String.drop_prefix s 1 |> Fn.flip String.drop_suffix 1
+
+let map_elements (to_str: json -> string) (parameters: (string * json) list): (string * string) list =
+  List.map parameters ~f:(fun (k,j) -> (k,to_str j))
+
+let optional_int ~(none: int) = function
+| `Int n when n = none -> "None"
+| `Int n -> "(Some " ^ Int.to_string n ^ ")"
+| x -> json_to_string x
+
+let optional_int_list = function
+| `List xs -> "(Some [" ^ String.concat ~sep:"; " (List.map ~f:json_to_string xs) ^ "])"
+| _ -> "None"
+
+let optional_int_or_string ~(none: int) = function
+| `String s -> "(Some \"" ^ s ^ "\")"
+| `Int n when n = none -> "None"
+| x -> json_to_string x
+
+let default_value ~(key: string) ~(value: string) (parameters: (string * string) list): (string * string) list =
+  if List.exists ~f:(fun (k, _) -> k = key) parameters
+  then parameters
+  else (key, value) :: parameters
+
+let optional_strings ~(f: string -> bool) (parameters: (string * json) list): (string * string) list =
+  let replace parameter =
+    let (k, v) = parameter in
+    if f k
+    then (k, "(Some " ^ json_to_string v ^ ")")
+    else (k, json_to_string v) in
+  List.map ~f:replace parameters
+
+let option_of_null (value: json): string = match value with
+| `Null -> "None"
+| `String s -> "(Some \"" ^ s ^ "\")"
+| `List xs as l -> "(Some " ^ (json_to_string l) ^ ")"
+| _ -> failwith "cannot handle this type"
+
+let is_empty_string (value: json): bool = match value with
+| `String s -> String.is_empty s
+| _ -> false
+
+let edit_connect_expected = function
+| `String "X" -> "(Some X)"
+| `String "O" -> "(Some O)"
+| `String "" -> "None"
+| x -> failwith "Bad json value in connect " ^ json_to_string x
+
+let edit_change_expected (value: json) = match value with
+| `List xs -> "(Some [" ^ (String.concat ~sep:"; " (List.map ~f:json_to_string xs)) ^ "])"
+| `Int (-1) -> "None"
+| _ -> failwith "Bad json value in change"
+
+let edit_bowling_expected (value: json) = match value with
+| `Int n -> "(Ok " ^ (Int.to_string n) ^ ")"
+| `Assoc [(k, v)] -> 
+    if k = "error" then "(Error " ^ json_to_string v ^ ")" else failwith ("Can only handle error value but got " ^ k)
+| _ -> failwith "Bad json value in bowling"
+
+let ocaml_edit_expected ~(stringify: json -> string) ~(slug: string) ~(value: json) = match slug with
+| "hamming" -> optional_int ~none:(-1) value
+| "all-your-base" -> optional_int_list value
+| "say" -> optional_int_or_string ~none:(-1) value
+| "phone-number" -> option_of_null value
+| "connect" -> edit_connect_expected value
+| "change" -> edit_change_expected value
+| "bowling" -> edit_bowling_expected value
+| "binary-search" -> optional_int ~none:(-1) value
+| "forth" -> option_of_null value
+| _ -> stringify value
+
+let edit_say (ps: (string * json) list) =
+  let edit = function
+  | ("input", v) -> ("input", let v = json_to_string v in if Int.of_string v >= 0 then "(" ^ v ^ "L)" else v ^ "L")
+  | (k, ps) -> (k, json_to_string ps) in
+  List.map ps ~f:edit
+
+let edit_all_your_base (ps: (string * json) list): (string * string) list =
+  let edit = function
+  | ("output_base", v) -> let v = json_to_string v in ("output_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
+  | ("input_base", v) -> let v = json_to_string v in ("input_base", if Int.of_string v >= 0 then v else "(" ^ v ^ ")")
+  | (k, v) -> (k, json_to_string v) in
+  List.map ps ~f:edit
+
+let edit_dominoes (ps: (string * json) list): (string * string) list =
+  let two_elt_list_to_tuple (j: json): string = match j with
+  | `List [`Int x1; `Int x2] -> sprintf "(%d,%d)" x1 x2
+  | _ -> failwith "two element list expected, but got " ^ (json_to_string j) in 
+  let edit (p: (string * json)) = match p with
+  | ("input", `List j) -> ("input", "[" ^ (List.map ~f:two_elt_list_to_tuple j |> String.concat ~sep:"; ") ^ "]")
+  | (k, v) -> (k, json_to_string v) in
+  List.map ps ~f:edit
+
+
+let edit_space_age (ps: (string * json) list): (string * string) list =
+  let edit = function
+  | ("planet", v) -> ("planet", json_to_string v |> strip_quotes) 
+  | (k, v) -> (k, json_to_string v) in
+  List.map ps ~f:edit
+  
+let edit_bowling (ps: (string * json) list): (string * string) list =
+  let edit = function
+  | ("property", v) -> ("property", json_to_string v |> strip_quotes) 
+  | ("roll", `Int n) -> ("roll", let s = Int.to_string n in if n < 0 then ("(" ^ s ^ ")") else s)
+  | (k, v) -> (k, json_to_string v) in
+  List.map ps ~f:edit
+
+let edit_binary_search (ps: (string * json) list): (string * string) list =
+  let open Yojson.Basic.Util in
+  let as_array_string xs = 
+    let xs = to_list xs |> List.map ~f:to_int |> List.map ~f:Int.to_string in
+    "[|" ^ String.concat ~sep:"; " xs ^ "|]" in
+  let edit = function
+  | ("array", v) -> ("array", as_array_string v) 
+  | (k, v) -> (k, json_to_string v) in
+  List.map ps ~f:edit
+
+let edit_parameters ~(slug: string) (parameters: (string * json) list) = match (slug, parameters) with
+| ("hello-world", ps) -> default_value ~key:"name" ~value:"None" (optional_strings ~f:(fun _x -> true) parameters)
+| ("say", ps) -> edit_say ps
+| ("all-your-base", ps) -> edit_all_your_base ps
+| ("dominoes", ps) -> edit_dominoes ps
+| ("space-age", ps) -> edit_space_age ps
+| ("bowling", ps) -> edit_bowling ps
+| ("binary-search", ps) -> edit_binary_search ps
+| (_, ps) -> map_elements json_to_string ps
+
+let expected_key_name slug = match slug with
+| "dominoes" -> "can_chain"
+| _ -> "expected"
+
+let cases_name _slug = "cases"