trackler 2.0.3.2 → 2.0.3.3

data/tracks/lua/exercises/secret-handshake/secret-handshake_spec.lua

@@ -0,0 +1,38 @@
+local secret_handshake = require 'secret-handshake'
+
+describe('secret-handshake', function()
+  it('should allow empty handshakes', function()
+    assert.are.same({}, secret_handshake(0))
+  end)
+
+  it('should interpret 0b1 as wink', function()
+    assert.are.same({ 'wink' }, secret_handshake(tonumber('1', 2)))
+  end)
+
+  it('should interpret 0b10 as double blink', function()
+    assert.are.same({ 'double blink' }, secret_handshake(tonumber('10', 2)))
+  end)
+
+  it('should interpret 0b100 as close your eyes', function()
+    assert.are.same({ 'close your eyes' }, secret_handshake(tonumber('100', 2)))
+  end)
+
+  it('should interpret 0b1000 as jump', function()
+    assert.are.same({ 'jump' }, secret_handshake(tonumber('1000', 2)))
+  end)
+
+  it('should allow multiple handshake primitives to be used together', function()
+    assert.are.same({ 'wink', 'double blink' }, secret_handshake(tonumber('11', 2)))
+  end)
+
+  it('should reverse the order of the primitives when 0b10000 is used', function()
+    assert.are.same({ 'double blink', 'wink' }, secret_handshake(tonumber('10011', 2)))
+  end)
+
+  it('should allow all primitives to be used together', function()
+    assert.are.same(
+      { 'jump', 'close your eyes', 'double blink', 'wink' },
+      secret_handshake(tonumber('11111', 2))
+    )
+  end)
+end)

data/tracks/ocaml/config.json

@@ -7,7 +7,11 @@
     {
       "slug": "hello-world",
       "difficulty": 1,
-      "topics": []
+      "topics": [
+        "Strings",
+        "Optional values",
+        "Pattern matching"
+      ]
     },
     {
       "slug": "leap",
@@ -69,6 +73,11 @@
       "difficulty": 3,
       "topics": []
     },
+    {
+      "slug": "bracket-push",
+      "difficulty": 4,
+      "topics": ["Stacks"]
+    },
     {
       "slug": "bowling",
       "difficulty": 4,

data/tracks/ocaml/exercises/bracket-push/.merlin

@@ -0,0 +1,3 @@
+PKG core oUnit
+S *
+B build/*

data/tracks/ocaml/exercises/bracket-push/Makefile

@@ -0,0 +1,11 @@
+test: test.native
+	@./test.native
+
+test.native: *.ml *.mli
+	@corebuild -r -quiet -pkg oUnit test.native
+
+clean:
+	rm -rf _build
+	rm -f test.native
+
+.PHONY: clean

data/tracks/ocaml/exercises/bracket-push/bracket_push.mli

@@ -0,0 +1,3 @@
+open Core.Std
+
+val are_balanced : string -> bool

data/tracks/ocaml/exercises/bracket-push/example.ml

@@ -0,0 +1,40 @@
+open Core.Std
+
+type 'a stack = 'a list
+
+let push (s: 'a stack) (a: 'a): 'a stack = a :: s
+let pop (s: 'a stack): ('a * 'a stack) option = match s with
+  | [] -> None
+  | x :: xs -> Some (x, xs)
+
+(* this receives a character from the input string s.
+   if the character is an opening bracket, then push it on to the stack, and
+   return the stack (inside an Option)
+   if the character is a closing bracket, then pop the top of the stack, and
+   check the popped character matches. If it does, then return the new stack,
+   otherwise return None (to indicate matching failure). *)
+let update (s: (char stack) option) (ch: char): (char stack) option =
+  match s with
+  | None -> None
+  | Some s ->
+    let pop_matching m = Option.filter (pop s) ~f:(fun (top, _) -> top = m)
+                         |> Option.map ~f:snd in
+    match ch with
+    | '(' | '{' | '[' -> Some (push s ch)
+    | ')' -> pop_matching '('
+    | '}' -> pop_matching '{'
+    | ']' -> pop_matching '['
+    | _ -> Some s
+
+(* The fold loops over the characters of s, repeatedly calling update on a stack
+   and each character of s.
+   If update ever encounters a non-matching bracket, it returns None, and the
+   fold will as well.
+   Otherwise, the fold will return a stack after going through all of the string.
+   If the stack is non-empty, then some non-matching brackets must remain, so the string
+   is not balanced.
+   If the stack is empty, everything matches, and the string balances.
+*)
+let are_balanced s =
+  List.fold_left (String.to_list s) ~init:(Some []) ~f:update
+  |> Option.exists ~f:(List.is_empty)

data/tracks/ocaml/exercises/bracket-push/test.ml

@@ -0,0 +1,38 @@
+open Core.Std
+open OUnit2
+open Bracket_push
+
+let ae exp got _test_ctxt =
+  assert_equal exp got ~printer:Bool.to_string
+
+let tests = [
+  "paired square brackets" >::
+    ae true (are_balanced "[]");
+  "empty string" >::
+    ae true (are_balanced "");
+  "unpaired brackets" >::
+    ae false (are_balanced "[[");
+  "wrong ordered brackets" >::
+    ae false (are_balanced "}{");
+  "paired with whitespace" >::
+    ae true (are_balanced "{ }");
+  "simple nested brackets" >::
+    ae true (are_balanced "{[]}");
+  "several paired brackets" >::
+    ae true (are_balanced "{}[]");
+  "paired and nested brackets" >::
+    ae true (are_balanced "([{}({}[])])");
+  "unopened closing brackets" >::
+    ae false (are_balanced "{[)][]}");
+  "unpaired and nested brackets" >::
+    ae false (are_balanced "([{])");
+  "paired and wrong nested brackets" >::
+    ae false (are_balanced "[({]})");
+  "math expression" >::
+    ae true (are_balanced "(((185 + 223.85) * 15) - 543)/2");
+  "complex latex expression" >::
+    ae true (are_balanced "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)");
+]
+
+let () =
+  run_test_tt_main ("bracket-push tests" >::: tests)

data/tracks/ocaml/exercises/leap/test.ml

@@ -5,19 +5,19 @@ open Leap
 let ae exp got _test_ctxt = assert_equal exp got
 
 let tests = [
-  "leap year" >::
+  "leap year in twentieth century" >::
     ae true (leap_year 1996);
-  "standard and odd year" >::
+  "odd standard year in twentieth century" >::
     ae false (leap_year 1997);
-  "standard even year" >::
+  "even standard year in twentieth century" >::
     ae false (leap_year 1998);
-  "standard nineteenth century" >::
+  "standard year in nineteenth century" >::
     ae false (leap_year 1900);
-  "standard eighteenth century" >::
+  "standard year in eighteenth century" >::
     ae false (leap_year 1800);
-  "leap twenty fourth century" >::
+  "leap year twenty four hundred" >::
     ae true (leap_year 2400);
-  "leap y2k" >::
+  "leap year two thousand" >::
     ae true (leap_year 2000);
 ]
 

data/tracks/ocaml/tools/test-generator/Makefile

@@ -2,10 +2,10 @@ test: test_gen.native
 	@./all_tests.native
 
 test_gen.native: all_tests.native src/*.ml interfaces/*.mli test/*.ml
-	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src,interfaces" test_gen.native
+	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is src,interfaces test_gen.native
 
 all_tests.native: src/*.ml test/*.ml
-	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg oUnit -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is "src,test" all_tests.native
+	@ocamlbuild -use-ocamlfind -tag thread -tag short_paths -cflags -strict-sequence -r -pkg core -pkg oUnit -pkg yojson -pkg ppx_deriving -pkg ppx_deriving.eq -pkg ppx_deriving.show -Is src,test all_tests.native
 
 clean:
 	rm -rf _build

data/tracks/ocaml/tools/test-generator/interfaces/codegen.mli

@@ -2,7 +2,7 @@ open Core.Std
 
 open Model
 
-type fixup_parameter_function = key: string -> value: parameter -> string
+type edit_expected_function = value: parameter -> string
 
 type edit_parameters_function = (string * string) list -> (string * string) list
 
@@ -10,4 +10,4 @@ type subst = Subst of string
 
 val subst_to_string : subst -> string
 
-val generate_code : fixup_parameter_function -> edit_parameters_function -> string -> case list -> (subst list, string) Result.t
+val fill_in_template : edit_expected_function -> edit_parameters_function -> string -> case list -> (subst list, string) Result.t

data/tracks/ocaml/tools/test-generator/interfaces/parser.mli

@@ -4,6 +4,12 @@ open Model
 type error = TopLevelMustHaveKeyCalledCases | ExpectingListOfCases |
              ExpectingMapForCase | BadDescription | BadExpected
 
-val parse_json_text : string -> (case list, error) Result.t
+type test = {name: string; cases: case list} [@@deriving eq, show]
+
+type tests =
+  | Single of case list
+  | Suite of test list [@@deriving eq, show]
+
+val parse_json_text : string -> (tests, error) Result.t
 
 val show_error : error -> string

data/tracks/ocaml/tools/test-generator/interfaces/special_cases.mli

@@ -2,6 +2,6 @@ open Core.Std
 
 open Model
 
-val fixup : stringify:(parameter -> string) -> slug:string -> key:string -> value:parameter -> string
+val edit_expected : stringify:(parameter -> string) -> slug:string -> key:string -> value:parameter -> string
 
-val edit : slug: string -> (string * string) list -> (string * string) list
+val edit_parameters : slug: string -> (string * string) list -> (string * string) list

data/tracks/ocaml/tools/test-generator/interfaces/utils.mli

@@ -9,8 +9,12 @@ val to_list_option : json -> json list option
 
 val to_list_note : 'e -> json -> ((json list, 'e) Result.t)
 
+val to_assoc_note : 'e -> json -> ((json list, 'e) Result.t)
+
 val to_string_note : 'e -> json -> ((string, 'e) Result.t)
 
+val member_note : 'e -> string -> json -> ((json, 'e) Result.t)
+
 val safe_to_int_option : json -> int option
 
 val find_arrayi : ?start:int -> 'a array -> f:('a -> bool) -> (int * 'a) option

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

@@ -2,7 +2,7 @@ open Core.Std
 
 open Model
 
-type fixup_parameter_function = key: string -> value: parameter -> string
+type edit_expected_function = value: parameter -> string
 
 type edit_parameters_function = (string * string) list -> (string * string) list
 
@@ -10,16 +10,20 @@ type subst = Subst of string [@@deriving eq, show]
 
 let subst_to_string (Subst s) = s
 
+let map_subst (s: subst) ~(f: string -> string): subst =
+  Subst (subst_to_string s |> f)
+
 let replace_key (key: string) (value: string) (target: string): string =
   let replace = String.substr_replace_all ~with_:value in
   replace ~pattern:("$" ^ key) target |> replace ~pattern:("$(" ^ key ^ ")")
 
-let rec replace_keys (f: fixup_parameter_function) (ed: edit_parameters_function) (s: string) (c: case): subst =
+let rec replace_keys (f: edit_expected_function) (ed: edit_parameters_function) (s: string) (suite_name: string) (c: case): subst =
   let s = replace_key "description" c.description s in
-  let expected = f ~key:"expected" ~value:c.expected in
+  let expected = f ~value:c.expected in
   let s = replace_key "expected" expected s in
+  let s = replace_key "suite-name" suite_name s in
   let parameter_strings = ed @@ List.map ~f:(fun (k,p) -> (k,parameter_to_string p)) c.parameters in
   List.fold parameter_strings ~init:(Subst s) ~f:(fun (Subst s) (k,v) -> Subst (replace_key k v s))
 
-let generate_code (f: fixup_parameter_function) (ed: edit_parameters_function) template cases =
-  Ok (List.map cases ~f:(replace_keys f ed template))
+let fill_in_template (f: edit_expected_function) (ed: edit_parameters_function) test_template suite_name cases =
+  List.map cases ~f:(replace_keys f ed test_template suite_name)

data/tracks/ocaml/tools/test-generator/src/{test_generator.ml → controller.ml}

@@ -21,27 +21,36 @@ let find_canonical_data_files = find_nested_files "canonical-data.json"
 let combine_files (template_files: (string * content) list) (canonical_data_files: (string * content) list): (string * content * content) list =
   List.filter_map template_files ~f:(fun (n,t) -> (List.Assoc.find canonical_data_files ~equal:String.equal n |> Option.map ~f:(fun c -> (n,t,c))))
 
-let generate_code ~slug ~template_file ~canonical_data_file =
+let generate_code ~(slug: string) ~(template_file: content) ~(canonical_data_file: content): (content, content) Result.t =
   let template = find_template template_file in
-  let template = Result.of_option template ("cannot recognize file for " ^ slug ^ " as a template") in
-  let cases = parse_json_text canonical_data_file in
-  let cases = Result.map_error cases show_error in
   let open Result.Monad_infix in
-  template >>= fun template ->
-  cases >>= fun cs ->
-  let substs = Result.ok_or_failwith @@ generate_code (fixup ~stringify:parameter_to_string ~slug) (edit ~slug) template.template cs in
-  Result.return (fill template substs)
-
-(* Hack - right now it's generating -1L, but Ocaml needs (-1L) *)
-let final_fixup (s: string): string =
-  String.substr_replace_all s ~pattern:"-1L" ~with_:"(-1L)"
+  Result.of_option template ("cannot recognize file for " ^ slug ^ " as a template") >>= fun template ->
+  parse_json_text canonical_data_file |> Result.map_error ~f:show_error >>= (function
+      | Single cases ->
+        Result.return (fill_in_template
+          (edit_expected ~stringify:parameter_to_string ~slug)
+          (edit_parameters ~slug)
+          template.template
+          slug
+          cases |> fill_tests template);
+      | Suite tests ->
+        let x = List.map tests ~f:(fun {name;cases} ->
+            (name, fill_in_template
+               (edit_expected ~stringify:parameter_to_string ~slug)
+               (edit_parameters ~slug)
+               template.template
+               name
+               cases)
+          ) in
+        Result.return (fill_suite template x)
+    )
 
 let output_tests (files: (string * content * content) list) (output_folder: string): unit =
   let output_filepath name = output_folder ^ "/" ^ name ^ "/test.ml" in
   let output1 (slug,t,c) =
-    let code = Result.ok_or_failwith @@ generate_code slug t c in
-    let code = final_fixup code in
-    Out_channel.write_all (output_filepath slug) code in
+    match generate_code slug t c with
+    | Ok code -> Out_channel.write_all (output_filepath slug) code
+    | Error e -> print_endline ("Failed when generating " ^ slug ^ ", error: " ^ e) in
   List.iter files ~f:output1
 
 let run ~(templates_folder: string) ~(canonical_data_folder: string) ~(output_folder: string) =

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

@@ -18,6 +18,12 @@ type case = {
   expected: parameter;
 } [@@deriving eq, show]
 
+type test = {name: string; cases: case list} [@@deriving eq, show]
+
+type tests =
+  | Single of case list
+  | Suite of test list [@@deriving eq, show]
+
 let surround (ch: char) (s: string): string =
   Char.to_string ch ^ s ^ Char.to_string ch
 

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

@@ -5,9 +5,8 @@ open Yojson.Safe.Util
 open Model
 
 type error =
-    TopLevelMustHaveKeyCalledCases | ExpectingListOfCases | ExpectingMapForCase |
-    BadDescription | BadExpected
-  [@@deriving eq]
+    TestMustHaveKeyCalledCases | ExpectingListOfCases | ExpectingMapForCase |
+    BadDescription | BadExpected | UnrecognizedJson [@@deriving eq, show]
 
 let to_int_unsafe = function
   | `Int x -> x
@@ -42,20 +41,48 @@ let parse_case (s: json): (case, error) Result.t = match s with
 
 let parse_cases (text: string): (json, error) Result.t =
   match from_string text |> member "cases" with
-    | `Null -> Error TopLevelMustHaveKeyCalledCases
+    | `Null -> Error TestMustHaveKeyCalledCases
     | json -> Ok json
 
-let parse_json_text (text: string): (case list, error) Result.t =
+let parse_single (text: string): (tests, error) Result.t =
   let open Result.Monad_infix in
   parse_cases text >>=
   to_list_note ExpectingListOfCases >>=
-  (sequence >> (List.map ~f:parse_case))
+  (sequence >> (List.map ~f:parse_case)) >>= fun ts ->
+  Result.return (Single ts)
+
+let is_suite (json: json) =
+  let keys = List.sort (keys json) ~cmp:String.compare in
+  not (List.is_empty keys || keys = ["cases"] || keys = ["#"; "cases"])
+
+let merge_result = function
+  | (_, Error x) -> Error x
+  | (n, Ok c) -> Ok {name = n; cases = c}
+
+let parse_cases_from_suite suite =
+  let open Result.Monad_infix in
+  member_note UnrecognizedJson "cases" suite >>=
+  to_list_note UnrecognizedJson >>= fun tests ->
+  List.map tests ~f:parse_case |> sequence
+
+let parse_json_text (text: string): (tests, error) Result.t =
+  let open Result.Monad_infix in
+  let json = from_string text in
+  if is_suite json
+  then
+    to_assoc_note UnrecognizedJson json >>= fun tests ->
+    Result.return (List.map tests ~f:(fun (name, suite) -> merge_result (name, parse_cases_from_suite suite))) >>= fun tests ->
+    sequence tests >>= fun tests ->
+    Ok (Suite tests)
+  else
+    parse_single text
 
 let show_error = function
-  | TopLevelMustHaveKeyCalledCases -> "Cannot parse this json - " ^
+  | TestMustHaveKeyCalledCases -> "Cannot parse this json - " ^
       "expecting an object with a key: 'cases'"
   | ExpectingMapForCase -> "Expected a json map for a test case"
   | ExpectingListOfCases -> "Expected a top level map with key cases, " ^
       "and a list of cases as its value."
   | BadDescription -> "Case is missing a description or it is not a string."
   | BadExpected -> "Case is missing an expected key or it is not a string."
+  | UnrecognizedJson -> "Cannot understand this json."

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

@@ -25,13 +25,20 @@ let optional_strings ~(f: string -> bool) (parameters: (string * string) list):
     else parameter in
   List.map ~f:replace parameters
 
-let fixup ~(stringify: parameter -> string) ~(slug: string) ~(key: string) ~(value: parameter) = match (slug, key) with
-  | ("hamming", "expected") -> optional_int ~none:(-1) value
-  | ("say", "expected") -> optional_int_or_string ~none:(-1) value
+let edit_expected ~(stringify: parameter -> string) ~(slug: string) ~(value: parameter) = match slug with
+  | "hamming" -> optional_int ~none:(-1) value
+  | "say" -> optional_int_or_string ~none:(-1) value
   | _ -> stringify value
 
-let edit ~(slug: string) (parameters: (string * string) list) = match (slug, parameters) with
+let edit_say (ps: (string * string) list) =
+  let edit = function
+    | ("input", v) -> ("input", if Int.of_string v < 0 then "(" ^ v ^ "L)" else v ^ "L")
+    | x -> x in
+  List.map ps ~f:edit
+
+let edit_parameters ~(slug: string) (parameters: (string * string) 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
   | (_, ps) -> ps