trackler 2.0.6.9 → 2.0.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b14825c924ae155ef47cfae4208988fc6fe0792a
-  data.tar.gz: d95acda90518c0b892a492427df1449ada88ef61
+  metadata.gz: 953233b1b3c26056a61ba8b0155589068f8a106e
+  data.tar.gz: 8111432be32d72c9ee0b52448735add2f6a11333
 SHA512:
-  metadata.gz: 6b246ba31cee380b84c8419cd4cc55ef0e52955888e5f1da274fff1956a71f9f5cb81e6f4625be50dc2d4a82d26650aee8372b2cde6377e3a149c083d681ae0d
-  data.tar.gz: 2248d24225e54c4ea418a19cdf51e68140f5993e92d869866a0553023b6623ab83f9a385b1a408910db48a21bf398ea4c76bae8cb3876909020b818deb91d84c
+  metadata.gz: 0f3b82d836515898a1a27435d01d86748105835110af07ccd8d05a542a0735e24a7112b005cda5aed1e0dc7aa96cbf7daba2b212f44ac70b9225f021d3e7ba36
+  data.tar.gz: 49a6dc1f57ba27a0afa3af2260caf0d8cddcf49148566f893b2434c7dd44ba25ccc2efadd51d619193f5ee8d29e7f81443da39f89b34262d74791d4ae8a2488f

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.9"
+  VERSION = "2.0.6.10"
 end

data/tracks/csharp/exercises/luhn/LuhnTest.cs

@@ -4,11 +4,11 @@ using NUnit.Framework;
 public class LuhnTest
 {
     [TestCase("1", ExpectedResult = false)] // single digit strings can not be valid
-    [TestCase("0", ExpectedResult = false, Ignore = "Remove to run test")] // a single zero is invalid
-    [TestCase("046 454 286", ExpectedResult = true, Ignore = "Remove to run test")] // valid Canadian SIN
-    [TestCase("046 454 287", ExpectedResult = false, Ignore = "Remove to run test")] // invalid Canadian SIN
-    [TestCase("8273 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test")] // invalid credit card
-    [TestCase("827a 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test")] // strings that contain non-digits are not valid
+    [TestCase("0", ExpectedResult = false, Ignore = "Remove to run test case")] // a single zero is invalid
+    [TestCase("046 454 286", ExpectedResult = true, Ignore = "Remove to run test case")] // valid Canadian SIN
+    [TestCase("046 454 287", ExpectedResult = false, Ignore = "Remove to run test case")] // invalid Canadian SIN
+    [TestCase("8273 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test case")] // invalid credit card
+    [TestCase("827a 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test case")] // strings that contain non-digits are not valid
     public bool ValidateChecksum(string number)
     {
         return Luhn.IsValid(number);

data/tracks/fsharp/exercises/luhn/LuhnTest.fs

@@ -4,10 +4,10 @@ open NUnit.Framework
 open Luhn
   
 [<TestCase("1", ExpectedResult = false)>] // single digit strings can not be valid
-[<TestCase("0", ExpectedResult = false, Ignore = "Remove to run test")>] // a single zero is invalid
-[<TestCase("046 454 286", ExpectedResult = true, Ignore = "Remove to run test")>] // valid Canadian SIN
-[<TestCase("046 454 287", ExpectedResult = false, Ignore = "Remove to run test")>] // invalid Canadian SIN
-[<TestCase("8273 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test")>] // invalid credit card
-[<TestCase("827a 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test")>] // strings that contain non-digits are not valid
+[<TestCase("0", ExpectedResult = false, Ignore = "Remove to run test case")>] // a single zero is invalid
+[<TestCase("046 454 286", ExpectedResult = true, Ignore = "Remove to run test case")>] // valid Canadian SIN
+[<TestCase("046 454 287", ExpectedResult = false, Ignore = "Remove to run test case")>] // invalid Canadian SIN
+[<TestCase("8273 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test case")>] // invalid credit card
+[<TestCase("827a 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test case")>] // strings that contain non-digits are not valid
 let ``Validate checksum`` number =
     valid number

data/tracks/fsharp/exercises/tree-building/Example.fs

@@ -5,6 +5,12 @@ type Tree =
     | Branch of int * Tree list
     | Leaf of int
 
+let recordId = function Branch (id, _) | Leaf id -> id
+
+let isBranch = function Branch _ -> true  | Leaf _ -> false
+
+let children = function Branch (_, children') -> children' | Leaf _ -> []
+
 let rootNodeRecordId = 0
 
 let addOrAppend key value map =

data/tracks/fsharp/exercises/tree-building/TreeBuilding.fs

@@ -5,6 +5,21 @@ type Tree =
     | Branch of int * Tree list
     | Leaf of int
 
+let recordId t = 
+    match t with
+    | Branch (id, c) -> id
+    | Leaf id -> id
+
+let isBranch t = 
+    match t with
+    | Branch (id, c) -> true
+    | Leaf id -> false
+
+let children t = 
+    match t with
+    | Branch (id, c) -> c
+    | Leaf id -> []
+
 let buildTree records = 
     let records' = List.sortBy (fun x -> x.RecordId) records
 

data/tracks/fsharp/exercises/tree-building/TreeBuildingTest.fs

@@ -10,8 +10,12 @@ let ``One node`` () =
         [ 
             { RecordId = 0; ParentId = 0 } 
         ]
-    let expected = Leaf 0
-    Assert.That(buildTree input, Is.EqualTo(expected))
+
+    let tree = buildTree input
+
+    Assert.That(isBranch tree, Is.False)
+    Assert.That(recordId tree, Is.EqualTo(0))    
+    Assert.That(children tree, Is.EqualTo([]))
 
 [<Test>]
 let ``Three nodes in order`` () =
@@ -21,8 +25,18 @@ let ``Three nodes in order`` () =
             { RecordId = 1; ParentId = 0 };
             { RecordId = 2; ParentId = 0 };
         ]
-    let expected = Branch (0, [Leaf 1; Leaf 2])
-    Assert.That(buildTree input, Is.EqualTo(expected))
+
+    let tree = buildTree input
+
+    Assert.That(isBranch tree, Is.True)
+    Assert.That(recordId tree, Is.EqualTo(0))
+    Assert.That(children tree |> List.length, Is.EqualTo(2))
+
+    Assert.That(children tree |> List.item 0 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))
+
+    Assert.That(children tree |> List.item 1 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
 
 [<Test>]
 let ``Three nodes in reverse order`` () =
@@ -32,8 +46,18 @@ let ``Three nodes in reverse order`` () =
             { RecordId = 1; ParentId = 0 };
             { RecordId = 0; ParentId = 0 };
         ]
-    let expected = Branch (0, [Leaf 1; Leaf 2])
-    Assert.That(buildTree input, Is.EqualTo(expected))
+
+    let tree = buildTree input
+    
+    Assert.That(isBranch tree, Is.True)
+    Assert.That(recordId tree, Is.EqualTo(0))
+    Assert.That(children tree |> List.length, Is.EqualTo(2))
+
+    Assert.That(children tree |> List.item 0 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))
+
+    Assert.That(children tree |> List.item 1 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
 
 [<Test>]
 let ``More than two children`` () =
@@ -44,8 +68,21 @@ let ``More than two children`` () =
             { RecordId = 1; ParentId = 0 };
             { RecordId = 0; ParentId = 0 };
         ]
-    let expected = Branch (0, [Leaf 1; Leaf 2; Leaf 3])
-    Assert.That(buildTree input, Is.EqualTo(expected))
+
+    let tree = buildTree input
+    
+    Assert.That(isBranch tree, Is.True)
+    Assert.That(recordId tree, Is.EqualTo(0))
+    Assert.That(children tree |> List.length, Is.EqualTo(3))
+
+    Assert.That(children tree |> List.item 0 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))
+
+    Assert.That(children tree |> List.item 1 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
+
+    Assert.That(children tree |> List.item 2 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 2 |> recordId, Is.EqualTo(3))
 
 [<Test>]
 let ``Binary tree`` () =
@@ -59,9 +96,32 @@ let ``Binary tree`` () =
             { RecordId = 0; ParentId = 0 };
             { RecordId = 6; ParentId = 2 }
         ]
-    let expected = Branch (0, [ Branch (1, [Leaf 4; Leaf 5]); 
-                                Branch (2, [Leaf 3; Leaf 6]) ])
-    Assert.That(buildTree input, Is.EqualTo(expected))
+
+    let tree = buildTree input
+        
+    Assert.That(isBranch tree, Is.True)
+    Assert.That(recordId tree, Is.EqualTo(0))
+    Assert.That(children tree |> List.length, Is.EqualTo(2))
+
+    Assert.That(children tree |> List.item 0 |> isBranch, Is.True)
+    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))    
+    Assert.That(children tree |> List.item 0 |> children |> List.length, Is.EqualTo(2))
+
+    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> recordId, Is.EqualTo(4))
+
+    Assert.That(children tree |> List.item 0 |> children |> List.item 1 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 0 |> children |> List.item 1 |> recordId, Is.EqualTo(5))
+    
+    Assert.That(children tree |> List.item 1 |> isBranch, Is.True)
+    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))    
+    Assert.That(children tree |> List.item 1 |> children |> List.length, Is.EqualTo(2))
+    
+    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> recordId, Is.EqualTo(3))
+
+    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> recordId, Is.EqualTo(6))
 
 [<Test>]
 let ``Unbalanced tree`` () =
@@ -75,9 +135,32 @@ let ``Unbalanced tree`` () =
             { RecordId = 0; ParentId = 0 };
             { RecordId = 6; ParentId = 2 }
         ]
-    let expected = Branch (0, [ Branch (1, [Leaf 4]); 
-                                Branch (2, [Leaf 3; Leaf 5; Leaf 6]) ])
-    Assert.That(buildTree input, Is.EqualTo(expected))
+
+    let tree = buildTree input
+        
+    Assert.That(isBranch tree, Is.True)
+    Assert.That(recordId tree, Is.EqualTo(0))
+    Assert.That(children tree |> List.length, Is.EqualTo(2))
+
+    Assert.That(children tree |> List.item 0 |> isBranch, Is.True)
+    Assert.That(children tree |> List.item 0 |> recordId, Is.EqualTo(1))    
+    Assert.That(children tree |> List.item 0 |> children |> List.length, Is.EqualTo(1))
+
+    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 0 |> children |> List.item 0 |> recordId, Is.EqualTo(4))
+    
+    Assert.That(children tree |> List.item 1 |> isBranch, Is.True)
+    Assert.That(children tree |> List.item 1 |> recordId, Is.EqualTo(2))
+    Assert.That(children tree |> List.item 1 |> children |> List.length, Is.EqualTo(3))
+    
+    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> children |> List.item 0 |> recordId, Is.EqualTo(3))
+
+    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> children |> List.item 1 |> recordId, Is.EqualTo(5))
+
+    Assert.That(children tree |> List.item 1 |> children |> List.item 2 |> isBranch, Is.False)
+    Assert.That(children tree |> List.item 1 |> children |> List.item 2 |> recordId, Is.EqualTo(6))
 
 [<Test>]
 let ``Empty input`` () =

data/tracks/go/config.json

@@ -29,7 +29,7 @@
       "difficulty": 1,
       "slug": "hello-world",
       "topics": [
-          "Control-flow (if-else statements)",
+          "Control-flow (conditionals)",
           "Optional values",
           "Strings",
           "Text formatting"

data/tracks/go/exercises/TRACK_HINTS.md

@@ -1,4 +1,4 @@
-To run the tests simply run the command `go test` in the exercise directory.
+To run the tests run the command `go test` from within the exercise directory.
 
 If the test suite contains benchmarks, you can run these with the `-bench`
 flag:

data/tracks/ocaml/config.json

@@ -141,6 +141,11 @@
       "difficulty": 7,
       "topics": []
     },
+    {
+      "slug": "dominoes",
+      "difficulty": 7,
+      "topics": []
+    },
     {
       "slug": "custom-set",
       "difficulty": 8,

data/tracks/ocaml/exercises/dominoes/.merlin

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

data/tracks/ocaml/exercises/dominoes/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/dominoes/dominoes.mli

@@ -0,0 +1,3 @@
+type dominoe = (int * int)
+
+val chain : dominoe list -> (dominoe list) option

data/tracks/ocaml/exercises/dominoes/example.ml

@@ -0,0 +1,51 @@
+(* Based off the Haskell solution by Tarmean at http://exercism.io/submissions/6dc2eef7e7eb469d8657111fc4389fc0 *)
+
+open Core.Std
+
+type dominoe = int * int
+
+(* Functions from Haskell that I can't find in Core! *)
+
+let zip_with (xs: 'a list) (ys: 'b list) ~(f: 'a -> 'b -> 'c) = 
+  let rec go xs ys acc = match (xs,ys) with
+  | (x::xs,y::ys) -> go xs ys @@ (f x y)::acc
+  | _ -> acc
+  in
+  List.rev @@ go xs ys []
+
+let tails (xs: 'a list): ('a list) list =
+  let rec go acc = function
+  | [] -> [] :: acc
+  | (x::xs) as l -> go (l :: acc) xs
+  in
+  List.rev @@ go [] xs
+
+let inits (xs: 'a list): ('a list) list =
+  List.rev xs |> tails |> List.map ~f:List.rev |> List.rev
+
+let listToOption = function
+| [] -> None
+| (x :: _) -> Some x
+
+(* The implementation *)
+
+let left (ds: dominoe list): int = ds |> List.hd_exn |> fst
+let right (ds: dominoe list): int = ds |> List.last_exn |> snd
+let choose_from (ls: 'a list): ('a * 'a list) list =
+  List.zip_exn ls @@ zip_with ~f:List.append (inits ls) (List.tl_exn (tails ls))
+
+let rec attach_to path ((a, b), rest) =
+  let lp = left path in
+  if b = lp then go rest ((a,b)::path)
+  else if a = lp then go rest ((b,a)::path)
+  else []
+and go stones path = match stones with
+| [] -> if left path = right path then [path] else []
+| _ -> let open List.Monad_infix in choose_from stones >>= attach_to path
+
+let chain_non_empty (first: dominoe) (rest: dominoe list): (dominoe list) option = 
+  listToOption @@ go rest [first]
+
+let chain = function
+| [] -> Some []
+| first::rest -> chain_non_empty first rest

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

@@ -0,0 +1,60 @@
+open Core.Std
+open OUnit2
+open Dominoes
+
+let print_dominoe (d1, d2) = sprintf "(%d,%d)" d1 d2
+
+let option_printer = function
+  | None -> "None"
+  | Some xs -> "Some [" ^ String.concat ~sep:";" (List.map xs ~f:print_dominoe) ^ "]"
+
+let drop_1_right xs = List.rev xs |> List.tl_exn |> List.rev
+
+let check_chain (chained: dominoe list) = 
+  let assert_dominoes_match d1 d2 =
+    if snd d1 <> fst d2 then failwith @@ sprintf "%s and %s cannot be chained together" (print_dominoe d1) (print_dominoe d2) else () in
+  let consecutives = List.zip_exn (drop_1_right chained) (List.tl_exn chained) in
+  List.iter consecutives ~f:(fun (d1, d2) -> assert_dominoes_match d1 d2)
+
+let assert_empty c = if List.is_empty c then () else failwith "Expected 0 length chain"
+
+let assert_valid_chain input _ctxt =
+  match chain input with
+  | None -> failwith "Expecting a chain"
+  | Some(c) -> (if List.is_empty input then assert_empty else check_chain) c  
+
+let assert_no_chain input _ctxt =
+  assert_equal None (chain input) ~printer:option_printer
+
+let assert_chain input hasChain =
+  if hasChain then assert_valid_chain input else assert_no_chain input
+
+let tests = [
+  "empty input = empty output" >::
+    assert_chain [] true;
+  "singleton input = singleton output" >::
+    assert_chain [(1,1)] true;
+  "singleton that can't be chained" >::
+    assert_chain [(1,2)] false;
+  "three elements" >::
+    assert_chain [(1,2); (3,1); (2,3)] true;
+  "can reverse dominoes" >::
+    assert_chain [(1,2); (1,3); (2,3)] true;
+  "can't be chained" >::
+    assert_chain [(1,2); (4,1); (2,3)] false;
+  "disconnected - simple" >::
+    assert_chain [(1,1); (2,2)] false;
+  "disconnected - double loop" >::
+    assert_chain [(1,2); (2,1); (3,4); (4,3)] false;
+  "disconnected - single isolated" >::
+    assert_chain [(1,2); (2,3); (3,1); (4,4)] false;
+  "need backtrack" >::
+    assert_chain [(1,2); (2,3); (3,1); (2,4); (2,4)] true;
+  "separate loops" >::
+    assert_chain [(1,2); (2,3); (3,1); (1,1); (2,2); (3,3)] true;
+  "ten elements" >::
+    assert_chain [(1,2); (5,3); (3,1); (1,2); (2,4); (1,6); (2,3); (3,4); (5,6)] true;
+]
+
+let () =
+  run_test_tt_main ("dominoes tests" >::: tests)

data/tracks/ruby/.travis.yml

@@ -9,6 +9,5 @@ script:
   - rubocop -fs -D
   - bin/executable-tests-check
   - rake test
-  - make test
   - bin/fetch-configlet
   - bin/configlet .

data/tracks/ruby/README.md

@@ -34,42 +34,32 @@ suite, you can run the file with a shim that temporarily disables them:
 ruby -I./lib -rdisable_skip exercise/exercise/filename_test.rb
 ```
 
-It is simpler to use the `make` tool which is available in the project
+It is simpler to use the `rake` tool which is available in the project
 root.  It will disable the skip calls for you automatically, it does the
 same thing as the above.
 
-If you would like to use the `make` tool to run a single test, while
+If you would like to use the `rake` tool to run a single test while
 developing clock, for example, you can do something like this:
 
 ```sh
-ASSIGNMENT=clock ARGS='-p' make test-assignment
+rake test:clock
 ```
 
-Where, "ASSIGNMENT" is the variable that holds the name of the lesson,
-clock.
-
-ARGS is where you can put additional arguments, here I am demonstrating
-the `-p` argument which may give you 'pride' output.
-
-If you use zsh, you can use the following function to make this process
-simple.
-
+To pass arguments to the test command, like `-p` for example, you can run
+the following:
 ```sh
-xtest () { ASSIGNMENT=$1 ARGS=$2 make test-assignment }
+rake test:clock -- -p
 ```
 
-Then you can simply use the command and exercise name, such as:
-
-`xtest binary`
-
-Or if you would like to use an option such as displaying the test names
-rather than just the dots, for example:
-
-`xtest clock -v`
+To show an example of running a limited number of tests, we will use the
+"hamming" exercise with a pattern of "identical" to run (currently) two tests:
+```sh
+rake test:hamming -- -p -n="/identical/"
+```
 
-Or with the pride reporter activated:
+Note that flags which have an attached value, like above, must take the form
+`-flag=value` and if `value` has spaces `-flag="value with spaces"`.
 
-`xtest robot-name -p`
 
 ### Generated Test Suites
 

data/tracks/ruby/Rakefile

@@ -1,9 +1,24 @@
 require 'rake'
 require 'rake/testtask'
 
-desc 'rake with no argument will run "rake test"'
-task default: :test
+require_relative 'lib/tasks/exercise_test_tasks'
 
-Rake::TestTask.new do |task|
-  task.pattern = 'test/**/*_test.rb'
+task default: 'test'
+
+desc 'Run individual exercises or run all development and exercise tests'
+task :test do
+  Rake::Task['test:dev'].invoke
+  Rake::Task['test:exercises'].invoke
+end
+
+namespace :test do
+  flags = ARGV.drop_while { |e| e != '--' }.drop(1).join(' ')
+
+  desc 'Run all development tests located in the test directory'
+  Rake::TestTask.new :dev do |task|
+    task.options = flags
+    task.pattern = 'test/**/*_test.rb'
+  end
+
+  ExerciseTestTasks.new options: flags
 end

data/tracks/ruby/bin/local-status-check

@@ -3,7 +3,7 @@
 puts "Starting #{__FILE__} checks..."
 
 commands_to_run = [
-  'make test',
+  'rake test',
   'bundle exec rubocop -fs -D',
   'bin/executable-tests-check',
 ]

data/tracks/ruby/lib/tasks/exercise.rb

@@ -0,0 +1,42 @@
+class Exercise
+  class << self
+    def all
+      exercise_names.map { |e| new(e) }
+    end
+
+    private
+
+    def exercise_names
+      FileList['exercises/*'].pathmap('%f').exclude('TRACK_HINTS.md')
+    end
+  end
+
+  attr_reader :name
+  alias :to_s :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def directory
+    "exercises/#{name}/."
+  end
+
+  def example_file
+    'example.rb'
+  end
+
+  def testable_example_file
+    "#{base_file_name}.rb"
+  end
+
+  def test_file
+    "#{base_file_name}_test.rb"
+  end
+
+  private
+
+  def base_file_name
+    @_base_file_name ||= name.tr('-', '_')
+  end
+end

data/tracks/ruby/lib/tasks/exercise_test_tasks.rb

@@ -0,0 +1,40 @@
+require 'rake/dsl_definition'
+
+require_relative 'exercise'
+require_relative 'exercise_tests_runner'
+
+class ExerciseTestTasks
+  include Rake::DSL
+
+  def initialize(options:, test_runner: ExerciseTestsRunner)
+    @options = options
+    @test_runner = test_runner
+
+    define
+  end
+
+  def define
+    define_task_for_all_exercises
+
+    exercises.each { |exercise| define_task_for(exercise) }
+  end
+
+  private
+
+  attr_reader :options, :test_runner
+
+  def exercises
+    @_exercises ||= Exercise.all
+  end
+
+  def define_task_for_all_exercises
+    desc 'Run the tests for all exercises'
+    task exercises: exercises
+  end
+
+  def define_task_for(exercise)
+    task exercise do
+      test_runner.new(exercise: exercise, test_options: options).run
+    end
+  end
+end

data/tracks/ruby/lib/tasks/exercise_tests_runner.rb

@@ -0,0 +1,33 @@
+require "rake/file_utils_ext"
+require 'tmpdir'
+
+class ExerciseTestsRunner
+  include Rake::FileUtilsExt
+
+  def initialize(exercise:, test_options: '')
+    @exercise = exercise
+    @test_options = test_options
+  end
+
+  def run
+    puts "\n\n#{'-'*64}\nrunning tests for: #{exercise}"
+
+    Dir.mktmpdir(exercise.name) do |dir|
+      setup_exercise_files_in(dir)
+      run_exercise_tests_in(dir)
+    end
+  end
+
+  private
+
+  attr_reader :exercise, :test_options
+
+  def setup_exercise_files_in(dir)
+    FileUtils.cp_r exercise.directory, dir
+    FileUtils.mv "#{dir}/#{exercise.example_file}", "#{dir}/#{exercise.testable_example_file}"
+  end
+
+  def run_exercise_tests_in(dir)
+    ruby "-I lib -r disable_skip.rb #{dir}/#{exercise.test_file} #{test_options}"
+  end
+end

data/tracks/ruby/test/tasks/exercise_test.rb

@@ -0,0 +1,46 @@
+require_relative '../test_helper'
+require 'tmpdir'
+
+class ExerciseTest < Minitest::Test
+  def test_all
+    Dir.mktmpdir('exercise-test') do |dir|
+      FileUtils.mkdir "#{dir}/test"
+      FileUtils.mkdir "#{dir}/test2"
+      FileUtils.touch "#{dir}/TRACK_HINTS.md"
+
+      FileList.stub :[], FileList["#{dir}/*"] do
+        assert_equal true, Exercise.all.all? { |e| e.instance_of?(Exercise) }
+        assert_equal ['test', 'test2'], Exercise.all.map(&:name)
+      end
+    end
+  end
+
+  def test_name
+    exercise = Exercise.new('name')
+    assert_equal 'name', exercise.name
+  end
+
+  def test_to_s
+    exercise = Exercise.new('name')
+    assert_equal 'name', exercise.to_s
+  end
+
+  def test_directory
+    exercise = Exercise.new('exercise_name')
+    assert_equal 'exercises/exercise_name/.', exercise.directory
+  end
+
+  def test_example_file
+    assert_equal 'example.rb', Exercise.new('').example_file
+  end
+
+  def test_testable_example_file
+    exercise = Exercise.new('all-your-base')
+    assert_equal 'all_your_base.rb', exercise.testable_example_file
+  end
+
+  def test_test_file
+    exercise = Exercise.new('all-your-base')
+    assert_equal 'all_your_base_test.rb', exercise.test_file
+  end
+end

data/tracks/ruby/test/tasks/exercise_test_tasks_test.rb

@@ -0,0 +1,49 @@
+require_relative '../test_helper'
+
+class ExerciseTestTasksTest < Minitest::Test
+  def test_all_exercises_task
+    setup_rake
+
+    Exercise.stub :all, ['test1', 'test2'] do
+      ExerciseTestTasks.new(options: '')
+
+      assert_equal ['test1', 'test2'], Rake::Task['exercises'].prerequisites
+      assert_equal 'Run the tests for all exercises', Rake::Task['exercises'].comment
+    end
+  end
+
+  def test_individual_exercise_tasks
+    setup_rake
+
+    Exercise.stub :all, ['test1', 'test2'] do
+      mock_test_runner_instance = Minitest::Mock.new
+      mock_test_runner_instance.expect :run, nil
+      mock_test_runner_instance.expect :run, nil
+
+      mock_test_runner = Minitest::Mock.new
+      mock_test_runner.expect(
+        :new,
+        mock_test_runner_instance,
+        [exercise: 'test1', test_options: '-p'],
+      )
+      mock_test_runner.expect(
+        :new,
+        mock_test_runner_instance,
+        [exercise: 'test2', test_options: '-p'],
+      )
+
+      ExerciseTestTasks.new(options: '-p', test_runner: mock_test_runner)
+
+      Rake::Task['test1'].invoke
+      Rake::Task['test2'].invoke
+
+      mock_test_runner.verify
+      mock_test_runner_instance.verify
+    end
+  end
+
+  def setup_rake
+    Rake.application = Rake::Application.new
+    Rake::TaskManager.record_task_metadata = true
+  end
+end

data/tracks/ruby/test/tasks/exercise_tests_runner_test.rb

@@ -0,0 +1,64 @@
+require_relative '../test_helper'
+
+class FakeExercise
+  def name
+    'test'
+  end
+
+  alias :to_s :name
+
+  def directory
+    'test/.'
+  end
+
+  def example_file
+    'example.rb'
+  end
+
+  def testable_example_file
+    'test.rb'
+  end
+
+  def test_file
+    'test_test.rb'
+  end
+end
+
+class ExerciseTestsRunnerTest < Minitest::Test
+  def test_run
+    Dir.stub :mktmpdir, nil, 'dir' do
+      cp_mock = Minitest::Mock.new.expect(:call, nil, ['test/.', 'dir'])
+
+      mv_mock = Minitest::Mock.new.expect(
+        :call,
+        nil,
+        ['dir/example.rb', 'dir/test.rb'],
+      )
+
+      ruby_mock = Minitest::Mock.new.expect(
+        :call,
+        nil,
+        ['-I lib -r disable_skip.rb dir/test_test.rb -p'],
+      )
+
+      FileUtils.stub :cp_r, cp_mock do
+        FileUtils.stub :mv, mv_mock do
+          runner = ExerciseTestsRunner.new(
+            exercise: FakeExercise.new,
+            test_options: '-p',
+          )
+
+          runner.stub :ruby, ruby_mock do
+            assert_output "\n\n#{'-'*64}\nrunning tests for: test\n" do
+              runner.run
+            end
+          end
+
+          cp_mock.verify
+          mv_mock.verify
+          ruby_mock.verify
+        end
+      end
+    end
+  end
+end

data/tracks/ruby/test/test_helper.rb

@@ -6,12 +6,21 @@ unless ENV['CI']
   require 'simplecov'
   SimpleCov.start do
     add_filter '/test/'
+
     add_group 'Generator' do |file|
       file.filename =~ /generator/
     end
+
+    add_group 'Tasks' do |file|
+      file.filename =~ /tasks/
+    end
+
     add_group 'Cases', '_cases.rb'
+
     add_group 'Other' do |file|
-      !(file.filename =~ /_cases\.rb$/) && file.filename !~ /generator/
+      !(file.filename =~ /_cases\.rb$/) &&
+        file.filename !~ /generator/ &&
+        file.filename !~ /tasks/
     end
   end
 end

data/tracks/scala/config.json

@@ -271,6 +271,9 @@
       "slug": "luhn",
       "difficulty": 1,
       "topics": [
+         "Strings",
+         "Algorithms",
+         "Transforming"
       ]
 		},
     {

data/tracks/scala/exercises/luhn/build.sbt

@@ -1,3 +1,3 @@
-scalaVersion := "2.11.7"
+scalaVersion := "2.12.1"
 
-libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/luhn/example.scala

@@ -1,23 +1,29 @@
-case class Luhn(number: Long) {
-  lazy val checkDigit: Int = (number % 10).toInt
+object Luhn {
 
-  lazy val addends: List[Int] = {
-    val zippedDigits = digits(number).zipWithIndex.reverse
+  def validate(numberStr: String): Boolean = {
+    def isCandidate(numberStr: String): Boolean =
+      numberStr.length > 1 &&
+      numberStr.forall(c => c.isDigit || c.isSpaceChar)
 
-    zippedDigits.map{case (m, i) => if (isOdd(i)) dbl(m) else m}
-  }
+    def toLong(numberStr: String): Long =
+      numberStr.filter(_.isDigit).toLong
 
-  lazy val checksum: Int = addends.sum % 10
+    val number =
+      Option(numberStr) filter isCandidate map toLong
 
-  lazy val isValid: Boolean = checksum % 10 == 0
+    number map (checksum(_) == 0) getOrElse false
+  }
 
-  lazy val create: Long = {
-    val m = number * 10
-    val luhn = Luhn(m)
+  private def checkDigit(number: Long): Int = (number % 10).toInt
 
-    if (luhn.isValid) m else m + (10 - luhn.checksum)
+  private def addends(number: Long): List[Int] = {
+    val zippedDigits = digits(number).zipWithIndex.reverse
+
+    zippedDigits.map{case (m, i) => if (isOdd(i)) dbl(m) else m}
   }
 
+  private def checksum(number: Long): Int = addends(number).sum % 10
+
   private def digits(n: Long): List[Int] = n match {
     case 0 => Nil
     case _ => List((n % 10).toInt) ++ digits(n / 10)
@@ -31,3 +37,4 @@ case class Luhn(number: Long) {
 
   private def isOdd(i: Int) = i % 2 == 1
 }
+

data/tracks/scala/exercises/luhn/src/test/scala/LuhnTest.scala

@@ -1,36 +1,33 @@
-import org.scalatest.{Matchers, FlatSpec}
+import org.scalatest.{FunSuite, Matchers}
 
-class LuhnTest extends FlatSpec with Matchers {
-  it should "create checkDigit" in {
-    Luhn(34567).checkDigit should equal(7)
-    Luhn(91370).checkDigit should equal(0)
-    Luhn(0).checkDigit should equal(0)
+class LuhnTest extends FunSuite with Matchers {
+  test("single digit strings can not be valid") {
+    Luhn.validate("1") should be (false)
   }
 
-  it should "create addends" in {
+  test("A single zero is invalid") {
     pending
-    Luhn(12121).addends should equal(List(1, 4, 1, 4, 1))
-    Luhn(8631).addends should equal(List(7, 6, 6, 1))
+    Luhn.validate("0") should be (false)
   }
 
-  it should "create checksum" in {
+  test("valid Canadian SIN") {
     pending
-    //  NOTE: this differs from the ruby and js, the checksum really should
-    //        be mod 10 like we are testing here.
-    Luhn(4913).checksum should equal(2)
-    Luhn(201773).checksum should equal(1)
+    Luhn.validate("046 454 286") should be (true)
   }
 
-  it should "check validity" in {
+  test("invalid Canadian SIN") {
     pending
-    Luhn(738).isValid should be (false)
-    Luhn(8739567).isValid should be (true)
+    Luhn.validate("046 454 287") should be (false)
   }
 
-  it should "create luhn values" in {
+  test("invalid credit card") {
     pending
-    Luhn(123).create should be (1230)
-    Luhn(873956).create should be (8739567)
-    Luhn(837263756).create should be (8372637564L)
+    Luhn.validate("8273 1232 7352 0569") should be (false)
+  }
+
+  test("strings that contain non-digits are not valid") {
+    pending
+    Luhn.validate("827a 1232 7352 0569") should be (false)
   }
 }
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.6.9
+  version: 2.0.6.10
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-11 00:00:00.000000000 Z
+date: 2017-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -4913,6 +4913,11 @@ files:
 - tracks/ocaml/exercises/difference-of-squares/difference_of_squares.mli
 - tracks/ocaml/exercises/difference-of-squares/example.ml
 - tracks/ocaml/exercises/difference-of-squares/test.ml
+- tracks/ocaml/exercises/dominoes/.merlin
+- tracks/ocaml/exercises/dominoes/Makefile
+- tracks/ocaml/exercises/dominoes/dominoes.mli
+- tracks/ocaml/exercises/dominoes/example.ml
+- tracks/ocaml/exercises/dominoes/test.ml
 - tracks/ocaml/exercises/etl/.merlin
 - tracks/ocaml/exercises/etl/Makefile
 - tracks/ocaml/exercises/etl/etl.mli
@@ -5937,7 +5942,6 @@ files:
 - tracks/ruby/Gemfile
 - tracks/ruby/HINTS.md
 - tracks/ruby/LICENSE
-- tracks/ruby/Makefile
 - tracks/ruby/README.md
 - tracks/ruby/Rakefile
 - tracks/ruby/bin/enable-executable
@@ -6235,6 +6239,9 @@ files:
 - tracks/ruby/lib/roman_numerals_cases.rb
 - tracks/ruby/lib/run_length_encoding_cases.rb
 - tracks/ruby/lib/sieve_cases.rb
+- tracks/ruby/lib/tasks/exercise.rb
+- tracks/ruby/lib/tasks/exercise_test_tasks.rb
+- tracks/ruby/lib/tasks/exercise_tests_runner.rb
 - tracks/ruby/lib/tournament_cases.rb
 - tracks/ruby/lib/transpose_cases.rb
 - tracks/ruby/lib/triangle_cases.rb
@@ -6256,6 +6263,9 @@ files:
 - tracks/ruby/test/generator/template_values_test.rb
 - tracks/ruby/test/generator_test.rb
 - tracks/ruby/test/grains_cases_test.rb
+- tracks/ruby/test/tasks/exercise_test.rb
+- tracks/ruby/test/tasks/exercise_test_tasks_test.rb
+- tracks/ruby/test/tasks/exercise_tests_runner_test.rb
 - tracks/ruby/test/test_helper.rb
 - tracks/ruby/test/wordy_cases_test.rb
 - tracks/rust/.git

data/tracks/ruby/Makefile

@@ -1,37 +0,0 @@
-.PHONY: test
-
-# assignments
-ASSIGNMENT ?= ""
-IGNOREDIRS := "^(\.git|bin|docs|lib|exercises)$$"
-ASSIGNMENTS = $(shell find ./exercises -maxdepth 1 -mindepth 1 -type d | awk -F/ '{print $$NF}' | sort | grep -Ev $(IGNOREDIRS))
-
-default: test
-
-# output directories
-TMPDIR ?= "/tmp/"
-OUTDIR := $(shell mktemp -d "$(TMPDIR)$(ASSIGNMENT).XXXXXXXXXX")
-
-# language specific config (tweakable per language)
-FILEEXT := "rb"
-EXAMPLE := "example.$(FILEEXT)"
-SRCFILE := "$(shell echo $(ASSIGNMENT) | sed 's/-/_/g')"
-TSTFILE := "$(SRCFILE)_test.$(FILEEXT)"
-# Any additional arguments, such as -p for pretty output and others
-ARGS ?= ""
-
-# single test
-test-assignment:
-	@echo ""
-	@echo ""
-	@echo "----------------------------------------------------------------"
-	@echo "running tests for: $(ASSIGNMENT)"
-	@cp -r ./exercises/$(ASSIGNMENT)/* $(OUTDIR)
-	@cp ./exercises/$(ASSIGNMENT)/$(EXAMPLE) $(OUTDIR)/$(SRCFILE).$(FILEEXT)
-	@ruby -I./lib -rdisable_skip.rb $(OUTDIR)/$(TSTFILE) $(ARGS)
-	@rm -rf $(OUTDIR)
-
-# all tests
-test:
-	@for assignment in $(ASSIGNMENTS); do \
-		ASSIGNMENT=$$assignment $(MAKE) -s test-assignment || exit 1;\
-	done