trackler 2.0.3.8 → 2.0.3.9

data/tracks/ocaml/tools/test-generator/test/parser_test.ml

@@ -17,7 +17,7 @@ let parser_tests = [
     ae (single []) (parse_json_text "{\"cases\" : []}");
 
   "gives an error with a json map that does not have the key cases in" >::
-    ae (Error UnrecognizedJson)
+    ae (Error (TestMustHaveKeyCalledCases "case"))
        (parse_json_text "{\"case\" : [{\"description\" : \"d1\", \"expected\" : 100}]}");
 
   "gives an error with cases that is not a json list" >::
@@ -61,15 +61,15 @@ let parser_tests = [
       (parse_json_text "{\"cases\" : [{\"description\" : \"d1\", \"input\" : [\"s1\", \"s2\"], \"expected\" : 85}]}");
 
   "an element without a description is an Error" >::
-    ae (Error BadDescription)
+    ae (Error NoDescription)
       (parse_json_text "{\"cases\" : [{\"input\" : 11, \"expected\" : 85}]}");
 
   "an element with a description which is an int is an Error" >::
     ae (Error BadDescription)
       (parse_json_text "{\"cases\" : [{\"description\" : 1, \"input\" : 11, \"expected\" : 85}]}");
 
-  "an element without expected is an Error" >::
-    ae (Error BadDescription)
+  "an element without description is an Error" >::
+    ae (Error NoDescription)
       (parse_json_text "{\"cases\" : [{\"input\" : 11}]}");
 
   "parses a map in the expected parameter" >::(fun _ctx ->
@@ -97,4 +97,18 @@ let parser_tests = [
       | Ok (Single p) -> assert_failure "was single"
       | Error e -> assert_failure ("failed to parse difference_of_squares.json: " ^ show_error e)
     );
+
+  "parses clock.json" >::(fun ctxt ->
+      match parse_json_text @@ In_channel.read_all "test/clock.json" with
+      | Ok (Suite p) -> assert_equal ["create"; "add"; "equal"] (List.map ~f:(fun x -> x.name) p)
+      | Ok (Single p) -> assert_failure "was single"
+      | Error e -> assert_failure ("failed to parse clock.json: " ^ show_error e)
+    );
+
+  "parses json with a methods key for dynamic languages" >::(fun ctxt ->
+      match parse_json_text @@ In_channel.read_all "test/with-methods-key.json" with
+      | Ok (Suite p) -> assert_failure "was suite"
+      | Ok (Single p) -> ()
+      | Error e -> assert_failure ("failed to parse with-methods-key.json: " ^ show_error e)
+    );
 ]

data/tracks/ocaml/tools/test-generator/test/with-methods-key.json

@@ -0,0 +1,22 @@
+{
+  "#": [
+    "Markdown is a shorthand for creating HTML from text strings."
+  ],
+  "methods": {
+    "description": [
+      "Check the public API is correct."
+    ],
+    "cases": [{
+      "description": "must be able to parse a Markdown string",
+      "method": "parse",
+      "arity": 1
+    }]
+  },
+  "cases": [
+    {
+       "description": "parses normal text as a paragraph",
+       "input": "This will be a paragraph",
+       "expected": "<p>This will be a paragraph</p>"
+    }
+  ]
+}

data/tracks/perl6/config.json

@@ -76,6 +76,11 @@
       "slug": "binary",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "wordy",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "trinary",

data/tracks/perl6/exercises/wordy/Example.p6

@@ -0,0 +1,16 @@
+sub answer($q is copy)  is export { 
+
+    given $q {
+        s:s:g/^What is|\?$//;
+        s:g/plus/+/;
+        s:g/minus/-/;
+
+        loop {
+            last unless s:s/(.*) multiplied by/($0)*/
+                     or s:s,(.*) divided by,($0)/,;
+        }
+    }
+
+    use MONKEY-SEE-NO-EVAL;
+    return EVAL $q;
+}

data/tracks/perl6/exercises/wordy/cases.json

@@ -0,0 +1,89 @@
+{
+  "#": [
+    "The tests that expect 'false' should be implemented to raise",
+    "an error, or indicate a failure. Implement this in a way that",
+    "makes sense for your language."
+  ],
+    "cases": [
+      {
+            "description": "addition",
+            "input": "What is 1 plus 1?",
+            "expected": 2
+      },
+      {
+            "description": "more addition",
+            "input": "What is 53 plus 2?",
+            "expected": 55
+      },
+      {
+            "description": "addition with negative numbers",
+            "input": "What is -1 plus -10?",
+            "expected": -11
+      },
+      {
+            "description": "large addition",
+            "input": "What is 123 plus 45678?",
+            "expected": 45801
+      },
+      {
+            "description": "subtraction",
+            "input": "What is 4 minus -12?",
+            "expected": 16
+      },
+      {
+            "description": "multiplication",
+            "input": "What is -3 multiplied by 25?",
+            "expected": -75
+      },
+      {
+            "description": "division",
+            "input": "What is 33 divided by -3?",
+            "expected": -11
+      },
+      {
+            "description": "multiple additions",
+            "input": "What is 1 plus 1 plus 1?",
+            "expected": 3
+      },
+      {
+            "description": "addition and subtraction",
+            "input": "What is 1 plus 5 minus -2?",
+            "expected": 8
+      },
+      {
+            "description": "multiple subtraction",
+            "input": "What is 20 minus 4 minus 13?",
+            "expected": 3
+      },
+      {
+            "description": "subtraction then addition",
+            "input": "What is 17 minus 6 plus 3?",
+            "expected": 14
+      },
+      {
+            "description": "multiple multiplication",
+            "input": "What is 2 multiplied by -2 multiplied by 3?",
+            "expected": -12
+      },
+      {
+            "description": "addition and multiplication",
+            "input": "What is -3 plus 7 multiplied by -2?",
+            "expected": -8
+      },
+      {
+            "description": "multiple division",
+            "input": "What is -12 divided by 2 divided by -3?",
+            "expected": 2
+      },
+      {
+            "description": "unknown operation",
+            "input": "What is 52 cubed?",
+            "expected": null
+      },
+      {
+            "description": "Non math question",
+            "input": "Who is the President of the United States?",
+            "expected": null
+      }
+    ]
+}

data/tracks/perl6/exercises/wordy/wordy.t

@@ -0,0 +1,29 @@
+#!/usr/bin/env perl6
+
+use Test;
+use JSON::Tiny;
+
+use lib ( my $dir = IO::Path.new($?FILE).parent ).path;
+
+my $module_name = %*ENV<EXERCISM>.so ?? 'Example' !! 'Wordy';
+my @potential_module = <p6 pm6 pm>.map:  $module_name ~ '.' ~ *; 
+
+my $module = first { $dir.child($_).e }, |@potential_module
+    or die "No file '$module_name.p6' found\n";
+
+require $module <&answer>;
+
+plan 16;
+
+my %cases = from-json $dir.child('cases.json').slurp;
+
+for |%cases<cases> -> %case {
+    with %case<expected> {
+        is answer(%case<input>), |%case<expected description>
+            or diag 'input: ' ~ %case<input>;
+    }
+    without %case<expected> {
+        dies-ok { answer(%case<input>) }, %case<description>
+            or diag 'input: ' ~ %case<input>;
+    }
+}

data/tracks/ruby/lib/generator.rb

@@ -14,20 +14,31 @@ class Generator
   end
 
   def metadata_dir
-    # rubocop:disable Metrics/LineLength
     File.expand_path(File.join('..', '..', '..', METADATA_REPOSITORY, 'exercises', name), __FILE__)
   end
 
+  def exercise_dir
+    File.expand_path(File.join('..', '..', 'exercises', name), __FILE__)
+  end
+
+  def exercise_meta_dir
+    File.join(exercise_dir,'.meta')
+  end
+
+  def version_filename
+    File.join(exercise_meta_dir,'.version')
+  end
+
   def data
     File.read(File.join(metadata_dir, 'canonical-data.json'))
   end
 
   def path_to(file)
-    File.expand_path(File.join('..', '..', 'exercises', name, file), __FILE__)
+    File.join(exercise_dir,file)
   end
 
   def version
-    @version ||= File.read(path_to('.version')).strip.to_i
+    @version ||= File.read(version_filename).strip.to_i
   end
 
   def sha1
@@ -70,7 +81,7 @@ class Generator
   end
 
   def increment_version
-    File.open(path_to('.version'), 'w') do |f|
+    File.open(version_filename, 'w') do |f|
       f.write version + 1
     end
   end

data/tracks/rust/config.json

@@ -17,6 +17,7 @@
     "scrabble-score",
     "pangram",
     "nucleotide-count",
+    "largest-series-product",
     "word-count",
     "atbash-cipher",
     "etl",

data/tracks/rust/exercises/largest-series-product/.gitignore

@@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

data/tracks/rust/exercises/largest-series-product/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "largest-series-product"
+version = "0.0.0"

data/tracks/rust/exercises/largest-series-product/HINTS.md

@@ -0,0 +1,6 @@
+# Largest Series Product in Rust
+
+These iterators may be useful, depending on your approach
+
+- [Windows](https://doc.rust-lang.org/std/primitive.slice.html#method.windows)
+- [Product](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.product)

data/tracks/rust/exercises/largest-series-product/example.rs

@@ -0,0 +1,22 @@
+pub fn lsp(string_digits: &str, span: usize) -> Result<u64, String> {
+    if span == 0 {
+        return Ok(1);
+    }
+
+    if string_digits.chars().any(|c| !c.is_digit(10)) {
+        return Err(String::from("All characters must be numbers"));
+    }
+
+    let products: Vec<u64> = string_digits.chars()
+        .map(|c| c.to_digit(10).unwrap() as u64)
+        .collect::<Vec<u64>>()
+        .windows(span)
+        .map(|w| w.into_iter().product())
+        .collect();
+
+    if let Some(&x) = products.iter().max() {
+        Ok(x)
+    } else {
+        Err(String::from("Span longer than string"))
+    }
+}

data/tracks/rust/exercises/largest-series-product/tests/largest-series-product.rs

@@ -0,0 +1,105 @@
+extern crate largest_series_product;
+
+use largest_series_product::*;
+
+#[test]
+fn return_is_a_result() {
+    assert!(lsp("29", 2).is_ok());
+}
+
+#[test]
+#[ignore]
+fn find_the_largest_product_when_span_equals_length() {
+    assert_eq!(18, lsp("29", 2).unwrap());
+}
+
+#[test]
+#[ignore]
+fn find_the_largest_product_of_two_with_numbers_in_order() {
+    assert_eq!(72, lsp("0123456789", 2).unwrap());
+}
+
+#[test]
+#[ignore]
+fn find_the_largest_product_of_two_with_numbers_not_in_order() {
+    assert_eq!(48, lsp("576802143", 2).unwrap());
+}
+
+#[test]
+#[ignore]
+fn find_the_largest_product_of_three_with_numbers_in_order() {
+    assert_eq!(504, lsp("0123456789", 3).unwrap());
+}
+
+#[test]
+#[ignore]
+fn find_the_largest_product_of_three_with_numbers_not_in_order() {
+    assert_eq!(270, lsp("1027839564", 3).unwrap());
+}
+
+#[test]
+#[ignore]
+fn find_the_largest_product_of_five_with_numbers_in_order() {
+    assert_eq!(15120, lsp("0123456789", 5).unwrap());
+}
+
+#[test]
+#[ignore]
+fn span_of_six_in_a_large_number() {
+    assert_eq!(23520,
+               lsp("73167176531330624919225119674426574742355349194934", 6).unwrap());
+}
+
+#[test]
+#[ignore]
+fn returns_zero_if_number_is_zeros() {
+    assert_eq!(0, lsp("0000", 2).unwrap());
+}
+
+#[test]
+#[ignore]
+fn returns_zero_if_all_products_are_zero() {
+    assert_eq!(0, lsp("99099", 3).unwrap());
+}
+
+#[test]
+#[ignore]
+fn a_span_is_longer_than_number_is_an_error() {
+    assert!(lsp("123", 4).is_err());
+}
+
+// There may be some confusion about whether this should be 1 or error.
+// The reasoning for it being 1 is this:
+// There is one 0-character string contained in the empty string.
+// That's the empty string itself.
+// The empty product is 1 (the identity for multiplication).
+// Therefore LSP('', 0) is 1.
+// It's NOT the case that LSP('', 0) takes max of an empty list.
+// So there is no error.
+// Compare against LSP('123', 4):
+// There are zero 4-character strings in '123'.
+// So LSP('123', 4) really DOES take the max of an empty list.
+// So LSP('123', 4) errors and LSP('', 0) does NOT.
+#[test]
+#[ignore]
+fn an_empty_string_and_no_span_returns_one() {
+    assert_eq!(1, lsp("", 0).unwrap());
+}
+
+#[test]
+#[ignore]
+fn a_non_empty_string_and_no_span_returns_one() {
+    assert_eq!(1, lsp("123", 0).unwrap());
+}
+
+#[test]
+#[ignore]
+fn empty_string_and_non_zero_span_is_an_error() {
+    assert!(lsp("", 1).is_err());
+}
+
+#[test]
+#[ignore]
+fn a_string_with_non_digits_is_an_error() {
+    assert!(lsp("1234a5", 2).is_err());
+}