trackler 2.1.0.1 → 2.1.0.2

data/tracks/ruby/exercises/all-your-base/all_your_base_test.rb

@@ -1,7 +1,7 @@
 require 'minitest/autorun'
 require_relative 'all_your_base'
 
-# Test data version: aa12f2e
+# Common test data version: 39de23b
 class AllYourBaseTest < Minitest::Test
   def test_single_bit_one_to_decimal
     # skip

data/tracks/ruby/exercises/all-your-base/example.tt

@@ -2,13 +2,14 @@ require 'minitest/autorun'
 require_relative 'all_your_base'
 
 # Common test data version: <%= abbreviated_commit_hash %>
-class AllYourBaseTest < Minitest::Test<% test_cases.each do |test_case| %>
-  def <%= test_case.test_name %>
+class AllYourBaseTest < Minitest::Test
+<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
     <%= test_case.skipped %>
 <%= test_case.workload %>
   end
-<% end %>
 
+<% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
   def test_bookkeeping
     skip

data/tracks/ruby/exercises/alphametics/alphametics_test.rb

@@ -3,7 +3,7 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'alphametics'
 
-# Test data version: 9dab356
+# Common test data version: b9bada8
 class AlphameticsTest < Minitest::Test
 
   def test_puzzle_with_three_letters
@@ -89,6 +89,7 @@ class AlphameticsTest < Minitest::Test
   #
   # If you are curious, read more about constants on RubyDoc:
   # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
   def test_bookkeeping
     skip
     assert_equal 4, BookKeeping::VERSION

data/tracks/ruby/exercises/alphametics/example.tt

@@ -8,13 +8,14 @@ class AlphameticsTest < Minitest::Test
 <% test_cases.each do |test_case| %>
 
 <%= test_case.runtime_comment %>
-  def <%= test_case.test_name %>
+  def <%= test_case.name %>
     <%= test_case.skipped %>
     <%= test_case.workload %>
   end
 <% end %>
 
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+
   def test_bookkeeping
     skip
     assert_equal <%= version %>, BookKeeping::VERSION

data/tracks/ruby/exercises/anagram/anagram_test.rb

@@ -3,119 +3,134 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'anagram'
 
-# Test data version:
-# 6a886e0
+# Common test data version: 196fc1a
 class AnagramTest < Minitest::Test
   def test_no_matches
     # skip
     detector = Anagram.new('diaper')
     anagrams = detector.match(["hello", "world", "zombies", "pants"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
   def test_detects_simple_anagram
     skip
     detector = Anagram.new('ant')
     anagrams = detector.match(["tan", "stand", "at"])
-    assert_equal ["tan"], anagrams
+    expected = ["tan"]
+    assert_equal expected, anagrams
   end
 
   def test_does_not_detect_false_positives
     skip
     detector = Anagram.new('galea')
     anagrams = detector.match(["eagle"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
-  def test_detects_multiple_anagrams
+  def test_detects_two_anagrams
     skip
     detector = Anagram.new('master')
     anagrams = detector.match(["stream", "pigeon", "maters"])
-    assert_equal ["maters", "stream"], anagrams.sort
+    expected = ["maters", "stream"]
+    assert_equal expected, anagrams.sort
   end
 
   def test_does_not_detect_anagram_subsets
     skip
     detector = Anagram.new('good')
     anagrams = detector.match(["dog", "goody"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
   def test_detects_anagram
     skip
     detector = Anagram.new('listen')
     anagrams = detector.match(["enlists", "google", "inlets", "banana"])
-    assert_equal ["inlets"], anagrams
+    expected = ["inlets"]
+    assert_equal expected, anagrams
   end
 
-  def test_detects_multiple_anagrams
+  def test_detects_three_anagrams
     skip
     detector = Anagram.new('allergy')
     anagrams = detector.match(["gallery", "ballerina", "regally", "clergy", "largely", "leading"])
-    assert_equal ["gallery", "largely", "regally"], anagrams.sort
+    expected = ["gallery", "largely", "regally"]
+    assert_equal expected, anagrams.sort
   end
 
   def test_does_not_detect_identical_words
     skip
     detector = Anagram.new('corn')
     anagrams = detector.match(["corn", "dark", "Corn", "rank", "CORN", "cron", "park"])
-    assert_equal ["cron"], anagrams
+    expected = ["cron"]
+    assert_equal expected, anagrams
   end
 
   def test_does_not_detect_non_anagrams_with_identical_checksum
     skip
     detector = Anagram.new('mass')
     anagrams = detector.match(["last"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
   def test_detects_anagrams_case_insensitively
     skip
     detector = Anagram.new('Orchestra')
     anagrams = detector.match(["cashregister", "Carthorse", "radishes"])
-    assert_equal ["Carthorse"], anagrams
+    expected = ["Carthorse"]
+    assert_equal expected, anagrams
   end
 
   def test_detects_anagrams_using_case_insensitive_subject
     skip
     detector = Anagram.new('Orchestra')
     anagrams = detector.match(["cashregister", "carthorse", "radishes"])
-    assert_equal ["carthorse"], anagrams
+    expected = ["carthorse"]
+    assert_equal expected, anagrams
   end
 
   def test_detects_anagrams_using_case_insensitive_possible_matches
     skip
     detector = Anagram.new('orchestra')
     anagrams = detector.match(["cashregister", "Carthorse", "radishes"])
-    assert_equal ["Carthorse"], anagrams
+    expected = ["Carthorse"]
+    assert_equal expected, anagrams
   end
 
   def test_does_not_detect_a_word_as_its_own_anagram
     skip
     detector = Anagram.new('banana')
     anagrams = detector.match(["Banana"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
   def test_does_not_detect_a_anagram_if_the_original_word_is_repeated
     skip
     detector = Anagram.new('go')
     anagrams = detector.match(["go Go GO"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
   def test_anagrams_must_use_all_letters_exactly_once
     skip
     detector = Anagram.new('tapper')
     anagrams = detector.match(["patter"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
   def test_capital_word_is_not_own_anagram
     skip
     detector = Anagram.new('BANANA')
     anagrams = detector.match(["Banana"])
-    assert_equal [], anagrams
+    expected = []
+    assert_equal expected, anagrams
   end
 
   # Problems in exercism evolve over time, as we find better ways to ask

data/tracks/ruby/exercises/anagram/example.rb

@@ -1,5 +1,5 @@
 module BookKeeping
-  VERSION=2
+  VERSION = 2
 end
 
 class Anagram

data/tracks/ruby/exercises/anagram/example.tt

@@ -4,13 +4,16 @@ require 'minitest/autorun'
 require_relative 'anagram'
 
 # Common test data version: <%= abbreviated_commit_hash %>
-class AnagramTest < Minitest::Test<% test_cases.each do |test_case| %>
-  def <%= test_case.test_name %>
+class AnagramTest < Minitest::Test
+<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
     <%= test_case.skipped %>
     <%= test_case.workload %>
   end
+
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+
   def test_bookkeeping
     skip
     assert_equal <%= version %>, BookKeeping::VERSION

data/tracks/ruby/exercises/beer-song/beer_song_test.rb

@@ -383,6 +383,7 @@ Go to the store and buy some more, 99 bottles of beer on the wall.
 TEXT
     assert_equal expected, BeerSong.new.verses(99, 0)
   end
+
   # Problems in exercism evolve over time, as we find better ways to ask
   # questions.
   # The version number refers to the version of the problem you solved,

data/tracks/ruby/exercises/beer-song/example.tt

@@ -5,14 +5,16 @@ require 'minitest/autorun'
 require_relative 'beer_song'
 
 # Common test data version: <%= abbreviated_commit_hash %>
-class BeerSongTest < Minitest::Test<% test_cases.each do |test_case| %>
-  def <%= test_case.test_name %>
+class BeerSongTest < Minitest::Test
+<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
     <%= test_case.skipped %>
     expected = <<-TEXT
 <%= test_case.expected %>
-    TEXT
-    assert_equal expected, <%= test_case.workload %>
+TEXT
+    <%= test_case.workload %>
   end
+
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
   def test_bookkeeping

data/tracks/ruby/exercises/binary/binary_test.rb

@@ -4,8 +4,7 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'binary'
 
-# Test data version:
-# 82eb00d
+# Common test data version: 969717d
 class BinaryTest < Minitest::Test
   def test_binary_0_is_decimal_0
     # skip
@@ -81,6 +80,7 @@ class BinaryTest < Minitest::Test
     skip
     assert_raises(ArgumentError) { Binary.to_decimal('001 nope') }
   end
+
   # Problems in exercism evolve over time, as we find better ways to ask
   # questions.
   # The version number refers to the version of the problem you solved,
@@ -97,6 +97,7 @@ class BinaryTest < Minitest::Test
   #
   # If you are curious, read more about constants on RubyDoc:
   # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
   def test_bookkeeping
     skip
     assert_equal 3, BookKeeping::VERSION

data/tracks/ruby/exercises/binary/example.tt

@@ -5,13 +5,16 @@ require 'minitest/autorun'
 require_relative 'binary'
 
 # Common test data version: <%= abbreviated_commit_hash %>
-class BinaryTest < Minitest::Test<% test_cases.each do |test_case| %>
+class BinaryTest < Minitest::Test
+<% test_cases.each do |test_case| %>
   def <%= test_case.name %>
     <%= test_case.skipped %>
-    <%= test_case.assertion %>
+    <%= test_case.workload %>
   end
+
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+
   def test_bookkeeping
     skip
     assert_equal <%= version %>, BookKeeping::VERSION

data/tracks/ruby/exercises/bowling/bowling_test.rb

@@ -3,207 +3,206 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'bowling'
 
-# Test data version: c59c2c4
-#
+# Common test data version: 3cf5eb9
 class BowlingTest < Minitest::Test
   def setup
     @game = Game.new
   end
 
-  def roll(rolls)
+  def record(rolls)
     rolls.each { |pins| @game.roll(pins) }
   end
 
   def test_should_be_able_to_score_a_game_with_all_zeros
     # skip
-    roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_equal 0, @game.score
   end
 
   def test_should_be_able_to_score_a_game_with_no_strikes_or_spares
     skip
-    roll([3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6])
+    record([3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6])
     assert_equal 90, @game.score
   end
 
   def test_a_spare_followed_by_zeros_is_worth_ten_points
     skip
-    roll([6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    record([6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_equal 10, @game.score
   end
 
   def test_points_scored_in_the_roll_after_a_spare_are_counted_twice
     skip
-    roll([6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    record([6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_equal 16, @game.score
   end
 
   def test_consecutive_spares_each_get_a_one_roll_bonus
     skip
-    roll([5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    record([5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_equal 31, @game.score
   end
 
   def test_a_spare_in_the_last_frame_gets_a_one_roll_bonus_that_is_counted_once
     skip
-    roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7])
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7])
     assert_equal 17, @game.score
   end
 
   def test_a_strike_earns_ten_points_in_a_frame_with_a_single_roll
     skip
-    roll([10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    record([10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_equal 10, @game.score
   end
 
   def test_points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus
     skip
-    roll([10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    record([10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_equal 26, @game.score
   end
 
   def test_consecutive_strikes_each_get_the_two_roll_bonus
     skip
-    roll([10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    record([10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_equal 81, @game.score
   end
 
   def test_a_strike_in_the_last_frame_gets_a_two_roll_bonus_that_is_counted_once
     skip
-    roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1])
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1])
     assert_equal 18, @game.score
   end
 
   def test_rolling_a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll
     skip
-    roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3])
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3])
     assert_equal 20, @game.score
   end
 
   def test_strikes_with_the_two_roll_bonus_do_not_get_bonus_rolls
     skip
-    roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10])
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10])
     assert_equal 30, @game.score
   end
 
   def test_a_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get_a_bonus
     skip
-    roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10])
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10])
     assert_equal 20, @game.score
   end
 
   def test_all_strikes_is_a_perfect_game
     skip
-    roll([10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])
+    record([10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])
     assert_equal 300, @game.score
   end
 
   def test_rolls_can_not_score_negative_points
     skip
+    record([])
     assert_raises Game::BowlingError do
-      roll([-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-      @game.score
+      @game.roll(-1)
     end
   end
 
   def test_a_roll_can_not_score_more_than_10_points
     skip
+    record([])
     assert_raises Game::BowlingError do
-      roll([11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-      @game.score
+      @game.roll(11)
     end
   end
 
   def test_two_rolls_in_a_frame_can_not_score_more_than_10_points
     skip
+    record([5])
     assert_raises Game::BowlingError do
-      roll([5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-      @game.score
+      @game.roll(6)
     end
   end
 
   def test_bonus_roll_after_a_strike_in_the_last_frame_can_not_score_more_than_10_points
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11])
-      @game.score
+      @game.roll(11)
     end
   end
 
   def test_two_bonus_rolls_after_a_strike_in_the_last_frame_can_not_score_more_than_10_points
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6])
-      @game.score
+      @game.roll(6)
     end
   end
 
   def test_two_bonus_rolls_after_a_strike_in_the_last_frame_can_score_more_than_10_points_if_one_is_a_strike
     skip
-    roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6])
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6])
     assert_equal 26, @game.score
   end
 
   def test_the_second_bonus_rolls_after_a_strike_in_the_last_frame_can_not_be_a_strike_if_the_first_one_is_not_a_strike
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6, 10])
-      @game.score
+      @game.roll(10)
     end
   end
 
   def test_second_bonus_roll_after_a_strike_in_the_last_frame_can_not_score_than_10_points
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 11])
-      @game.score
+      @game.roll(11)
     end
   end
 
   def test_an_unstarted_game_can_not_be_scored
     skip
+    record([])
     assert_raises Game::BowlingError do
-      roll([])
       @game.score
     end
   end
 
   def test_an_incomplete_game_can_not_be_scored
     skip
+    record([0, 0])
     assert_raises Game::BowlingError do
-      roll([0, 0])
       @game.score
     end
   end
 
-  def test_a_game_with_more_than_ten_frames_can_not_be_scored
+  def test_cannot_roll_if_game_already_has_ten_frames
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-      @game.score
+      @game.roll(0)
     end
   end
 
   def test_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10])
       @game.score
     end
   end
 
   def test_both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10])
       @game.score
     end
   end
 
   def test_bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated
     skip
+    record([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3])
     assert_raises Game::BowlingError do
-      roll([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3])
       @game.score
     end
   end