trackler 2.1.0.0 → 2.1.0.1

data/tracks/perl6/exercises/clock/example.yaml

@@ -0,0 +1,16 @@
+exercise: Clock
+version: 1
+methods: time add-minutes
+plan: 54
+tests: |
+  is ::($exercise).new(hour => .<hour>, minute => .<minute>).?time, |.<expected description> for @($c-data<cases>[0]<cases>);
+  for @($c-data<cases>[1]<cases>) {
+    my $clock = ::($exercise).new(hour => .<hour>, minute => .<minute>);
+    $clock.?add-minutes(.<add>);
+    is $clock.?time, |.<expected description>;
+  }
+  is ::($exercise).new(hour => .<clock1><hour>, minute => .<clock1><minute>).?time eq
+     ::($exercise).new(hour => .<clock2><hour>, minute => .<clock2><minute>).?time,
+     |.<expected description> for @($c-data<cases>[2]<cases>);
+  todo 'optional test' unless %*ENV<EXERCISM>;
+  is ::($exercise).new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';

data/tracks/perl6/exercises/robot-name/Example.pm

@@ -1,11 +1,18 @@
 unit class Robot:ver<1>;
 
-state %record;
-
-has Str:D $.name = self.reset-name;
+subset Name of Str where * ~~ /^<[A..Z]>**2 <[0..9]>**3$/;
+has Name $.name = self.reset-name;
 
 method reset-name {
-  $!name = ('AA'..'ZZ').roll ~ ('000'..'999').roll;
+  state Promise:D $promise = start ('AA000'..'ZZ999').pick: *;
+  state Bool:D %record{Name:D};
+  state Int:D $i = 0;
+
+  if $promise.status ~~ 'Kept' {
+    ($!name = $promise.result[$i++]) or die 'All names used.';
+  } else {
+    $!name = ('A'..'Z').roll(2).join ~ (^10).roll(3).join;
+  }
   self.reset-name if %record{$!name}:exists;
   %record{$!name} = True;
   return $!name;

data/tracks/php/exercises/hello-world/hello-world.php

@@ -5,7 +5,7 @@
 // It's been provided as a convenience to get you started writing code faster.
 //
 
-function helloWorld($name = null)
+function helloWorld()
 {
     //
     // YOUR CODE GOES HERE

data/tracks/php/exercises/hello-world/hello-world_test.php

@@ -4,18 +4,8 @@ require "hello-world.php";
 
 class HelloWorldTest extends PHPUnit\Framework\TestCase
 {
-    public function testNoName()
+    public function testHelloWorld()
     {
         $this->assertEquals('Hello, World!', helloWorld());
     }
-
-    public function testSampleName()
-    {
-        $this->assertEquals('Hello, Alice!', helloWorld('Alice'));
-    }
-
-    public function testAnotherSampleName()
-    {
-        $this->assertEquals('Hello, Bob!', helloWorld('Bob'));
-    }
 }

data/tracks/php/exercises/robot-name/robot-name_test.php

@@ -61,6 +61,7 @@ class RobotTest extends PHPUnit\Framework\TestCase
         }
     }
 
+    // This test is optional.
     public function testNameUniquenessManyRobots()
     {
         $names = [];

data/tracks/purescript/config.json

@@ -159,6 +159,13 @@
       "topics": [
         "maps"
       ]
+    },
+    {
+      "slug": "largest-series-product",
+      "difficulty": 1,
+      "topics": [
+        "strings"
+      ]
     }
   ],
   "deprecated": [

data/tracks/purescript/exercises/largest-series-product/bower.json

@@ -0,0 +1,16 @@
+{
+  "name": "largest-series-product",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-prelude": "^3.0.0"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^11.0.0"
+  }
+}

data/tracks/purescript/exercises/largest-series-product/examples/src/LargestSeriesProduct.purs

@@ -0,0 +1,31 @@
+module LargestSeriesProduct
+  ( largestProduct
+  ) where
+
+import Prelude
+import Data.Array (drop, length, take, (:))
+import Data.Foldable (maximum, product)
+import Data.Int (fromString)
+import Data.Maybe (Maybe(..))
+import Data.String (singleton, toCharArray)
+import Data.Traversable (sequence)
+
+spans :: forall a. Int -> Array a -> Array (Array a)
+spans n a
+  | length a < n = []
+  | otherwise    = take n a : spans n (drop 1 a)
+
+toIntArray :: String -> Maybe (Array Int)
+toIntArray = toCharArray
+             >>> map (singleton >>> fromString) 
+             >>> sequence
+
+largestProduct :: String -> Int -> Maybe Int
+largestProduct digits span
+  | span == 0 = Just 1
+  | span < 0  = Nothing
+  | otherwise = do
+    is <- toIntArray digits
+    spans span is
+      # map product
+      # maximum

data/tracks/purescript/exercises/largest-series-product/src/LargestSeriesProduct.purs

@@ -0,0 +1,3 @@
+module LargestSeriesProduct
+  ( largestProduct
+  ) where

data/tracks/purescript/exercises/largest-series-product/test/Main.purs

@@ -0,0 +1,73 @@
+module Test.Main where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Data.Maybe (Maybe(..))
+import Test.Unit.Assert as Assert
+import Test.Unit (suite, test)
+import Test.Unit.Main (runTest)
+import LargestSeriesProduct (largestProduct)
+
+main :: Eff _ Unit
+main = runTest do
+  suite "LargestSeriesProduct.largestProduct" do
+    
+    test "finds the largest product if span equals length" $
+      Assert.equal (Just 18)
+                   (largestProduct "29" 2)
+    
+    test "can find the largest product of 2 with numbers in order" $
+      Assert.equal (Just 72)
+                   (largestProduct "0123456789" 2)
+    
+    test "can find the largest product of 2" $
+      Assert.equal (Just 48)
+                   (largestProduct "576802143" 2)
+    
+    test "can find the largest product of 3 with numbers in order" $
+      Assert.equal (Just 504)
+                   (largestProduct "0123456789" 3)
+    
+    test "can find the largest product of 3" $
+      Assert.equal (Just 270)
+                   (largestProduct "1027839564" 3)
+    
+    test "can find the largest product of 5 with numbers in order" $
+      Assert.equal (Just 15120)
+                   (largestProduct "0123456789" 5)
+    
+    test "can get the largest product of a big number" $
+      Assert.equal (Just 23520)
+                   (largestProduct "73167176531330624919225119674426574742355349194934" 6)
+    
+    test "reports zero if the only digits are zero" $
+      Assert.equal (Just 0)
+                   (largestProduct "0000" 2)
+    
+    test "reports zero if all spans include zero" $
+      Assert.equal (Just 0)
+                   (largestProduct "99099" 3)
+    
+    test "rejects span longer than string length" $
+      Assert.equal Nothing
+                   (largestProduct "123" 4)
+    
+    test "reports 1 for empty string and empty product (0 span)" $
+      Assert.equal (Just 1)
+                   (largestProduct "" 0)
+    
+    test "reports 1 for nonempty string and empty product (0 span)" $
+      Assert.equal (Just 1)
+                   (largestProduct "123" 0)
+    
+    test "rejects empty string and nonzero span" $
+      Assert.equal Nothing
+                   (largestProduct "" 1)
+    
+    test "rejects invalid character in digits" $
+      Assert.equal Nothing
+                   (largestProduct "1234a5" 2)
+    
+    test "rejects negative span" $
+      Assert.equal Nothing
+                   (largestProduct "12345" (-1))

data/tracks/python/exercises/sublist/sublist_test.py

@@ -3,94 +3,133 @@ import unittest
 from sublist import check_lists, SUBLIST, SUPERLIST, EQUAL, UNEQUAL
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class SublistTest(unittest.TestCase):
-    def test_unique_return_vals(self):
+    def test_unique_return_values(self):
         self.assertEqual(len(set([SUBLIST, SUPERLIST, EQUAL, UNEQUAL])), 4)
 
     def test_empty_lists(self):
-        self.assertEqual(check_lists([], []), EQUAL)
-
-    def test_empty_list_within(self):
-        self.assertEqual(check_lists([], [1, 2, 3]), SUBLIST)
-
-    def test_within_empty_list(self):
-        self.assertEqual(check_lists([1], []), SUPERLIST)
-
-    def test_equal_lists(self):
-        l1 = [0, 1, 2]
-        l2 = [0, 1, 2]
-        self.assertEqual(check_lists(l1, l2), EQUAL)
+        self.assertEqual(
+            check_lists([], []),
+            EQUAL
+        )
+
+    def test_empty_list_within_non_empty_list(self):
+        self.assertEqual(
+            check_lists([], [1, 2, 3]),
+            SUBLIST
+        )
+
+    def test_non_empty_list_contains_empty_list(self):
+        self.assertEqual(
+            check_lists([1, 2, 3], []),
+            SUPERLIST
+        )
+
+    def test_list_equals_itself(self):
+        self.assertEqual(
+            check_lists([1, 2, 3], [1, 2, 3]),
+            EQUAL
+        )
 
     def test_different_lists(self):
-        l1 = list(range(1000000))
-        l2 = list(range(1, 1000001))
-        self.assertEqual(check_lists(l1, l2), UNEQUAL)
+        self.assertEqual(
+            check_lists([1, 2, 3], [2, 3, 4]),
+            UNEQUAL
+        )
 
     def test_false_start(self):
-        l1 = [1, 2, 5]
-        l2 = [0, 1, 2, 3, 1, 2, 5, 6]
-        self.assertEqual(check_lists(l1, l2), SUBLIST)
+        self.assertEqual(
+            check_lists([1, 2, 5], [0, 1, 2, 3, 1, 2, 5, 6]),
+            SUBLIST
+        )
 
     def test_consecutive(self):
-        l1 = [1, 1, 2]
-        l2 = [0, 1, 1, 1, 2, 1, 2]
-        self.assertEqual(check_lists(l1, l2), SUBLIST)
+        self.assertEqual(
+            check_lists([1, 1, 2], [0, 1, 1, 1, 2, 1, 2]),
+            SUBLIST
+        )
 
     def test_sublist_at_start(self):
-        l1 = [0, 1, 2]
-        l2 = [0, 1, 2, 3, 4, 5]
-        self.assertEqual(check_lists(l1, l2), SUBLIST)
+        self.assertEqual(
+            check_lists([0, 1, 2], [0, 1, 2, 3, 4, 5]),
+            SUBLIST
+        )
 
     def test_sublist_in_middle(self):
-        l1 = [2, 3, 4]
-        l2 = [0, 1, 2, 3, 4, 5]
-        self.assertEqual(check_lists(l1, l2), SUBLIST)
+        self.assertEqual(
+            check_lists([2, 3, 4], [0, 1, 2, 3, 4, 5]),
+            SUBLIST
+        )
 
     def test_sublist_at_end(self):
-        l1 = [3, 4, 5]
-        l2 = [0, 1, 2, 3, 4, 5]
-        self.assertEqual(check_lists(l1, l2), SUBLIST)
+        self.assertEqual(
+            check_lists([3, 4, 5], [0, 1, 2, 3, 4, 5]),
+            SUBLIST
+        )
 
     def test_at_start_of_superlist(self):
-        l1 = [0, 1, 2, 3, 4, 5]
-        l2 = [0, 1, 2]
-        self.assertEqual(check_lists(l1, l2), SUPERLIST)
+        self.assertEqual(
+            check_lists([0, 1, 2, 3, 4, 5], [0, 1, 2]),
+            SUPERLIST
+        )
 
     def test_in_middle_of_superlist(self):
-        l1 = [0, 1, 2, 3, 4, 5]
-        l2 = [2, 3]
-        self.assertEqual(check_lists(l1, l2), SUPERLIST)
+        self.assertEqual(
+            check_lists([0, 1, 2, 3, 4, 5], [2, 3]),
+            SUPERLIST
+        )
 
     def test_at_end_of_superlist(self):
-        l1 = [0, 1, 2, 3, 4, 5]
-        l2 = [3, 4, 5]
-        self.assertEqual(check_lists(l1, l2), SUPERLIST)
+        self.assertEqual(
+            check_lists([0, 1, 2, 3, 4, 5], [3, 4, 5]),
+            SUPERLIST
+        )
+
+    def test_first_list_missing_element_from_second_list(self):
+        self.assertEqual(
+            check_lists([1, 3], [1, 2, 3]),
+            UNEQUAL
+        )
+
+    def test_second_list_missing_element_from_first_list(self):
+        self.assertEqual(
+            check_lists([1, 2, 3], [1, 3]),
+            UNEQUAL
+        )
+
+    def test_order_matters_to_a_list(self):
+        self.assertEqual(
+            check_lists([1, 2, 3], [3, 2, 1]),
+            UNEQUAL
+        )
+
+    def test_same_digits_but_different_numbers(self):
+        self.assertEqual(
+            check_lists([1, 0, 1], [10, 1]),
+            UNEQUAL
+        )
+
+    # additional track specific test
+    def test_inner_spaces(self):
+        self.assertEqual(
+            check_lists(['a c'], ['a', 'c']),
+            UNEQUAL
+        )
 
+    # additional track specific test
     def test_large_lists(self):
         l1 = list(range(1000)) * 1000 + list(range(1000, 1100))
         l2 = list(range(900, 1050))
         self.assertEqual(check_lists(l1, l2), SUPERLIST)
 
+    # additional track specific test
     def test_spread_sublist(self):
         multiples_of_3 = list(range(3, 200, 3))
         multiples_of_15 = list(range(15, 200, 15))
         self.assertEqual(check_lists(multiples_of_15, multiples_of_3), UNEQUAL)
 
-    def test_double_digits(self):
-        l1 = [1, 0, 1]
-        l2 = [10, 1]
-        self.assertEqual(check_lists(l1, l2), UNEQUAL)
-
-    def test_inner_spaces(self):
-        l1 = ['a c']
-        l2 = ['a', 'c']
-        self.assertEqual(check_lists(l1, l2), UNEQUAL)
-
-    def test_avoid_sets(self):
-        self.assertEqual(check_lists([1, 3], [1, 2, 3]), UNEQUAL)
-        self.assertEqual(check_lists([1, 2, 3], [1, 3]), UNEQUAL)
-        self.assertEqual(check_lists([1, 2, 3], [3, 2, 1]), UNEQUAL)
-
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/ruby/README.md

@@ -114,54 +114,48 @@ the exercise, which lives in the x-common repository.
 This change will need to be submitted as a pull request to the x-common repository. This pull
 request needs to be merged before you can regenerate the exercise.
 
-Changes that don't have to do directly with the test inputs and outputs, will either need to be
-made to `exercises/$PROBLEM/example.tt` or `lib/$PROBLEM_cases.rb`. Then you can regenerate the
-exercise with `bin/generate $PROBLEM`.
+Changes that don't have to do directly with the test inputs and outputs, will
+most likely be made to `lib/$PROBLEM_cases.rb` but may also be made to
+`exercises/$PROBLEM/example.tt`. Then you can regenerate the exercise with
+`bin/generate $PROBLEM`.
 
 #### Implementing a Generator
 
-You will need to implement three files to create a generator:
+You will need to implement two files and a directory to create a generator:
 
-1. `exercises/$PROBLEM/example.tt` - the Erb template for the test file, `$PROBLEM_test.rb`.
-1. `exercises/$PROBLEM/.meta/.version` - used to keep track of the version of the test files as the data changes.
 1. `lib/$PROBLEM_cases.rb` - the logic for turning the data into tests.
+1. `exercises/$PROBLEM/example.tt` - the Erb template for the test file, `$PROBLEM_test.rb`.
+1. `exercises/$PROBLEM/.meta/` - metadata directory, currently contains version file
 
 You will not need to touch the top-level script, `bin/generate`.
 
 The `bin/generate` command relies on some common logic implemented in `lib/generator.rb`.
 You probably won't need to touch that, either.
 
-The `lib/$PROBLEM_cases.rb` file should contain a small class that wraps the JSON for a single test case:
+`lib/$PROBLEM_cases.rb` contains a derived class of `ExerciseCase` (in `lib/generator/exercise_cases.rb`)
+which wraps the JSON for a single test case. The default version looks something like this:
 
 ```
-require 'exercise_cases'
-
-class ProblemNameCase < OpenStruct
-  def name
-    'test_%s' % description.gsub(/[ -]/, '_')
-  end
+class ProblemNameCase < ExerciseCase
 
   def workload
     # Example workload:
-    "assert #{expected.inspect}, Problem.call(#{input.inspect})"
+    "#{assert} Problem.call(#{input.inspect})"
   end
 
-  def skipped
-    index.zero? ? '# skip' : 'skip'
-  end
 end
 ```
 
-Instead of `ProblemName` use the name of the actual problem. This is important, since
+Instead of `ProblemName` use the CamelCased name of the actual problem. This is important, since
 the generator script will infer the name of the class from the argument that is passed.
 
-This class must implement the following methods:
-
-- `name` - Returns the name of the test (i.e `test_one_equals_one`)
-- `workload` - Returns the main syntax for the test. This includes the assertion and any setup required for the test.  This will vary depending on the test generator and its underlying implementation
-- `skipped` - Returns skip syntax (i.e. `skip` or `# skip`)
+This class must provide the methods used by `example.tt`. The base class provides methods
+for the default template for everything except `workload`.
 
-Beyond that, you can implement any helper methods that you need.
+`workload` generates the code for the body of a test, including the assertion
+and any setup required. The base class provides a variety of assertion and
+helper methods. Beyond that, you can implement any helper methods that you need
+as private methods in your derived class. See below for more information about [the intention of workload](#workload-philosophy)
 
 Below this class, implement a small loop that will generate all the test cases by reading the
 `canonical-data.json` file, and looping through the test cases.
@@ -198,7 +192,8 @@ end
 
 Finally, you need to create a text template, `example.tt`, as the bases for the test suite.
 
-Start with the following boilerplate, and adjust as necessary:
+Start with the following boilerplate, and adjust as necessary. Remember, however, to strive
+to keep logic out of views.
 
 ```
 #!/usr/bin/env ruby
@@ -216,12 +211,30 @@ class ProblemNameTest < Minitest::Test
 
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+
   def test_bookkeeping
     skip
     assert_equal <%= version %>, BookKeeping::VERSION
   end
 end
 ```
+### Workload philosophy.
+
+Prioritize educational value over expert comprehension and make sure that
+things are clear to people who may not be familiar with Minitest and even Ruby. 
+
+Provide the information the student needs to derive the code to pass the test
+in a clear and consistent manner. Illustrate the purpose of the individual
+elements of the assertion by using meaningful variable names.
+
+Example output from the `workload` method:
+```ruby
+detector = Anagram.new('allergy')
+anagrams = detector.match(["gallery", "ballerina", "regally", "clergy", "largely", "leading"])
+expected = ["gallery", "largely", "regally"]
+assert_equal expected, anagrams.sort
+```
+
 
 ## Pull Requests