trackler 2.0.0.1 → 2.0.0.2

data/tracks/ruby/config.json

@@ -4,89 +4,6 @@
   "repository": "https://github.com/exercism/xruby",
   "active": true,
   "gitter": "xruby",
-  "problems": [
-    "hello-world",
-    "hamming",
-    "gigasecond",
-    "rna-transcription",
-    "raindrops",
-    "difference-of-squares",
-    "pangram",
-    "sieve",
-    "roman-numerals",
-    "robot-name",
-    "nth-prime",
-    "leap",
-    "grains",
-    "word-count",
-    "bob",
-    "run-length-encoding",
-    "binary",
-    "accumulate",
-    "sum-of-multiples",
-    "grade-school",
-    "series",
-    "phone-number",
-    "prime-factors",
-    "strain",
-    "etl",
-    "trinary",
-    "beer-song",
-    "bowling",
-    "space-age",
-    "anagram",
-    "binary-search-tree",
-    "crypto-square",
-    "clock",
-    "alphametics",
-    "rail-fence-cipher",
-    "acronym",
-    "scrabble-score",
-    "nucleotide-count",
-    "flatten-array",
-    "hexadecimal",
-    "say",
-    "meetup",
-    "queen-attack",
-    "palindrome-products",
-    "bracket-push",
-    "food-chain",
-    "matrix",
-    "saddle-points",
-    "triangle",
-    "atbash-cipher",
-    "house",
-    "secret-handshake",
-    "proverb",
-    "ocr-numbers",
-    "pig-latin",
-    "simple-linked-list",
-    "luhn",
-    "simple-cipher",
-    "wordy",
-    "allergies",
-    "poker",
-    "kindergarten-garden",
-    "linked-list",
-    "pythagorean-triplet",
-    "robot-simulator",
-    "twelve-days",
-    "circular-buffer",
-    "largest-series-product",
-    "binary-search",
-    "two-bucket",
-    "pascals-triangle",
-    "custom-set",
-    "minesweeper",
-    "scale-generator",
-    "protein-translation",
-    "perfect-numbers",
-    "connect",
-    "list-ops",
-    "diamond",
-    "all-your-base",
-    "isogram"
-  ],
   "exercises": [
     {
       "slug": "hello-world",
@@ -573,6 +490,18 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "transpose",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "tournament",
+      "difficulty": 1,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [

data/tracks/ruby/exercises/allergies/allergies_test.rb

@@ -59,7 +59,6 @@ class AllergiesTest < Minitest::Test
   def test_allergic_to_everything
     skip
     allergies = Allergies.new(255)
-    # rubocop:disable Metrics/LineLength
     expected = %w(eggs peanuts shellfish strawberries tomatoes chocolate pollen cats)
     assert_equal expected, allergies.list
   end

data/tracks/ruby/exercises/atbash-cipher/atbash_cipher_test.rb

@@ -3,7 +3,6 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'atbash_cipher'
 
-# rubocop:disable Style/MethodName
 class AtbashTest < Minitest::Test
   def test_encode_no
     assert_equal 'ml', Atbash.encode('no')

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

@@ -3,7 +3,6 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'beer_song'
 
-# rubocop:disable Metrics/LineLength
 class BeerSongTest < Minitest::Test
   def test_the_first_verse
     expected = "99 bottles of beer on the wall, 99 bottles of beer.\n" \
@@ -62,7 +61,7 @@ class BeerSongTest < Minitest::Test
     assert_equal expected, BeerSong.new.verses(2, 0)
   end
 
-  def test_the_whole_song # rubocop:disable Metrics/MethodLength
+  def test_the_whole_song
     skip
     expected = <<-SONG
 99 bottles of beer on the wall, 99 bottles of beer.

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

@@ -19,7 +19,6 @@ class Binary
 
   private
 
-  # rubocop:disable Style/WordArray
   def valid?(s)
     s.chars.all? { |char| ['0', '1'].include?(char) }
   end

data/tracks/ruby/exercises/binary-search-tree/binary_search_tree_test.rb

@@ -32,7 +32,7 @@ class BstTest < Minitest::Test
     assert_equal 5, four.right.data
   end
 
-  def test_complex_tree # rubocop:disable Metrics/MethodLength
+  def test_complex_tree
     skip
     four = Bst.new 4
     four.insert 2

data/tracks/ruby/exercises/bowling/.version

@@ -0,0 +1 @@
+2

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

@@ -3,224 +3,200 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'bowling'
 
-class GameTest < Minitest::Test
+# Test data version:
+# 0a51cfc
+class BowlingTest < Minitest::Test
   def setup
     @game = Game.new
   end
 
-  def test_must_be_able_to_roll_with_number_of_pins
-    assert_respond_to @game, :roll
-    assert_equal 1, @game.method(:roll).arity
+  def roll(rolls)
+    rolls.each { |pins| @game.roll(pins) }
   end
 
-  def test_must_have_a_score
-    skip
-    assert_respond_to @game, :score
+  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])
+    assert_equal 0, @game.score
   end
 
-  def test_should_be_able_to_score_open_frame
+  def test_should_be_able_to_score_a_game_with_no_strikes_or_spares
     skip
-    @game.roll(3)
-    @game.roll(4)
-    roll_n_times(18, 0)
-    assert_equal 7, @game.score
+    roll([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_should_be_able_to_score_multiple_frames
+  def test_a_spare_followed_by_zeros_is_worth_ten_points
     skip
-    [3, 4, 2, 3, 5, 2].each do |pins|
-      @game.roll pins
-    end
-    roll_n_times(14, 0)
-    assert_equal 19, @game.score
+    roll([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_should_score_a_game_with_all_gutterballs
+  def test_points_scored_in_the_roll_after_a_spare_are_counted_twice
     skip
-    roll_n_times(20, 0)
-    assert_equal 0, @game.score
+    roll([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_should_score_a_game_with_all_single_pin_rolls
+  def test_consecutive_spares_each_get_a_one_roll_bonus
     skip
-    roll_n_times(20, 1)
-    assert_equal 20, @game.score
+    roll([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_should_allow_game_with_all_open_frames
+  def test_a_spare_in_the_last_frame_gets_a_one_roll_bonus_that_is_counted_once
     skip
-    roll_n_times(10, [3, 6])
-    assert_equal 90, @game.score
+    roll([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_should_correctly_score_a_strike_that_is_not_on_the_last_frame
+  def test_a_strike_earns_ten_points_in_frame_with_a_single_roll
     skip
-    @game.roll(10)
-    @game.roll(5)
-    @game.roll(3)
-    roll_n_times(16, 0)
-
-    assert_equal 26, @game.score
+    roll([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_should_score_a_spare_that_is_not_on_the_last_frame
+  def test_points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus
     skip
-    @game.roll(5)
-    @game.roll(5)
-    @game.roll(3)
-    @game.roll(4)
-    roll_n_times(16, 0)
-
-    assert_equal 20, @game.score
+    roll([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_should_score_multiple_strikes_in_a_row
+  def test_consecutive_strikes_each_get_the_two_roll_bonus
     skip
-    @game.roll(10)
-    @game.roll(10)
-    @game.roll(10)
-    @game.roll(5)
-    @game.roll(3)
-    roll_n_times(12, 0)
-
+    roll([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_should_score_multiple_spares_in_a_row
+  def test_a_strike_in_the_last_frame_gets_a_two_roll_bonus_that_is_counted_once
     skip
-    @game.roll(5)
-    @game.roll(5)
-    @game.roll(3)
-    @game.roll(7)
-    @game.roll(4)
-    @game.roll(1)
-    roll_n_times(14, 0)
-
-    assert_equal 32, @game.score
+    roll([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_should_allow_fill_balls_when_the_final_frame_is_strike
+  def test_rolling_a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll
     skip
-    roll_n_times(18, 0)
-    @game.roll(10)
-    @game.roll(7)
-    @game.roll(1)
-
-    assert_equal 18, @game.score
+    roll([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_should_allow_fill_ball_in_last_frame_if_spare
+  def test_strikes_with_the_two_roll_bonus_do_not_get_bonus_rolls
     skip
-    roll_n_times(18, 0)
-    @game.roll(9)
-    @game.roll(1)
-    @game.roll(7)
-
-    assert_equal 17, @game.score
+    roll([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_should_allow_fill_balls_to_be_strike
+  def test_a_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get_a_bonus
     skip
-    roll_n_times(18, 0)
-    @game.roll(10)
-    @game.roll(10)
-    @game.roll(10)
-
-    assert_equal 30, @game.score
+    roll([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_should_score_a_perfect_game
+  def test_all_strikes_is_a_perfect_game
     skip
-    roll_n_times(12, 10)
+    roll([10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])
     assert_equal 300, @game.score
   end
 
-  def test_should_not_allow_rolls_with_negative_pins
+  def test_rolls_can_not_score_negative_points
     skip
-    assert_raises(
-      RuntimeError,
-      'Pins must have a value from 0 to 10') do
-        @game.roll(-1)
-      end
+    assert_raises StandardError do
+      roll([-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+      @game.score
+    end
   end
 
-  def test_should_not_allow_rolls_better_than_strike
+  def test_a_roll_can_not_score_more_than_10_points
     skip
-    assert_raises(
-      RuntimeError,
-      'Pins must have a value from 0 to 10') do
-        @game.roll(11)
-      end
+    assert_raises StandardError do
+      roll([11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+      @game.score
+    end
   end
 
-  def test_should_not_allow_two_normal_rolls_better_than_strike
+  def test_two_rolls_in_a_frame_can_not_score_more_than_10_points
     skip
-    assert_raises RuntimeError, 'Pin count exceeds pins on the lane' do
-      @game.roll(5)
-      @game.roll(6)
+    assert_raises StandardError do
+      roll([5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+      @game.score
     end
   end
 
-  def test_should_not_allow_two_normal_rolls_better_than_strike_in_last_frame
+  def test_two_bonus_rolls_after_a_strike_in_the_last_frame_can_not_score_more_than_10_points
     skip
-    roll_n_times(18, 0)
-    assert_raises RuntimeError, 'Pin count exceeds pins on the lane' do
-      @game.roll(10)
-      @game.roll(5)
-      @game.roll(6)
+    assert_raises StandardError 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
     end
   end
 
-  def test_should_not_allow_to_take_score_at_the_beginning
+  def test_an_unstarted_game_can_not_be_scored
     skip
-    assert_raises(
-      RuntimeError,
-      'Score cannot be taken until the end of the game',
-    ) do
+    assert_raises StandardError do
+      roll([])
       @game.score
     end
   end
 
-  def test_should_not_allow_to_take_score_before_game_has_ended
+  def test_an_incomplete_game_can_not_be_scored
     skip
-    roll_n_times(19, 5)
-    assert_raises(
-      RuntimeError,
-      'Score cannot be taken until the end of the game') do
-        @game.score
-      end
+    assert_raises StandardError do
+      roll([0, 0])
+      @game.score
+    end
   end
 
-  def test_should_not_allow_rolls_after_the_tenth_frame
+  def test_a_game_with_more_than_ten_frames_can_not_be_scored
     skip
-    roll_n_times(20, 0)
-    assert_raises(
-      RuntimeError,
-      'Should not be able to roll after game is over',
-    ) do
-      @game.roll(0)
+    assert_raises StandardError 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
     end
   end
 
-  def test_should_not_calculate_score_before_fill_balls_have_been_played
+  def test_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated
     skip
-    roll_n_times(10, 10)
+    assert_raises StandardError 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
 
-    assert_raises RuntimeError, 'Game is not yet over, cannot score!' do
+  def test_both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated
+    skip
+    assert_raises StandardError 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 roll_n_times(rolls, pins)
-    rolls.times do
-      Array(pins).each { |value| @game.roll(value) }
+  def test_bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated
+    skip
+    assert_raises StandardError 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
-  private :roll_n_times
 
-  # Don't forget to define a constant VERSION inside of BookKeeping.
+  # 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,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # 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 1, BookKeeping::VERSION
+    assert_equal 2, BookKeeping::VERSION
   end
 end

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

@@ -1,9 +1,9 @@
 module BookKeeping
-  VERSION = 1
+  VERSION = 2
 end
 
 class Game
-  RULES = { MIN: 0, MAX: 10 }.freeze
+  PINS = { MIN: 0, MAX: 10 }.freeze
   at_exit { public :roll, :score }
 
   private
@@ -20,7 +20,7 @@ class Game
   end
 
   def validate(pins)
-    raise 'Invalid number of pins' unless (RULES[:MIN]..RULES[:MAX]).cover?(pins)
+    raise 'Invalid number of pins' unless (PINS[:MIN]..PINS[:MAX]).cover?(pins)
     raise 'Too many pins in frame' unless valid_frame?(pins)
     raise 'Game is over, no rolls allowed' if game_complete?
   end
@@ -28,8 +28,8 @@ class Game
   def valid_frame?(pins)
     last_roll_was_strike = @score_card[current_frame].last == 10
 
-    (last_frame? && last_roll_was_strike) ||
-    @score_card[current_frame].last.to_i + pins <= RULES[:MAX]
+    (last_frame? && last_roll_was_strike || spare?) ||
+      @score_card[current_frame].last.to_i + pins <= PINS[:MAX]
   end
 
   def score
@@ -40,10 +40,10 @@ class Game
   end
 
   def score_frame(f, i)
-    strike_or_spare = [f.first, f.inject(:+)].any? {|e| e == RULES[:MAX]}
+    strike_or_spare = [f.first, f.inject(:+)].any? { |e| e == PINS[:MAX] }
 
     if strike_or_spare
-      special(@score_card[i], @score_card[i+1], @score_card[i+2])
+      special(@score_card[i], @score_card[i + 1], @score_card[i + 2])
     else
       f.reduce(:+)
     end

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

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'bowling'
+
+# Test data version:
+# <%= sha1 %>
+class BowlingTest < Minitest::Test
+  def setup
+    @game = Game.new
+  end
+
+  def roll(rolls)
+    rolls.each { |pins| @game.roll(pins) }
+  end
+<% test_cases.each do |test_case| %>
+  def <%= test_case.test_name %>
+    <%= test_case.skipped %>
+    <%= test_case.work_load %>
+  end
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version.next %>, BookKeeping::VERSION
+  end
+end

data/tracks/ruby/exercises/circular-buffer/circular_buffer_test.rb

@@ -89,7 +89,6 @@ class CircularBufferTest < Minitest::Test
     assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
   end
 
-  # rubocop:disable Metrics/MethodLength
   def test_alternate_read_and_write_into_buffer_overflow
     skip
     buffer = CircularBuffer.new(5)
@@ -108,5 +107,4 @@ class CircularBufferTest < Minitest::Test
     assert_equal 'B', buffer.read
     assert_raises(CircularBuffer::BufferEmptyException) { buffer.read }
   end
-  # rubocop:enable Metrics/MethodLength
 end

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

@@ -12,7 +12,6 @@ class Clock
     @internal = hours * 60 + minutes
   end
 
-  # rubocop:disable Style/OpMethod
   def +(hours=0, minutes)
     @internal += hours * 60 + minutes
     self
@@ -21,7 +20,6 @@ class Clock
   def -(*args)
     self.+(*args.map(&:-@))
   end
-  # rubocop:enable Style/OpMethod
 
   def ==(other)
     to_s == other.to_s

data/tracks/ruby/exercises/connect/connect_test.rb

@@ -95,7 +95,6 @@ class ConnectTest < Minitest::Test
     assert_equal 'X', game.winner, 'X wins using a convoluted path'
   end
 
-  # rubocop:disable MethodLength
   def test_x_wins_using_a_spiral_path
     skip
     board = [

data/tracks/ruby/exercises/custom-set/custom_set_test.rb

@@ -204,7 +204,6 @@ class CustomSetTest < Minitest::Test
     assert_equal expected, set2.intersection(set1)
   end
 
-  # rubocop:disable Metrics/LineLength
   def test_intersection_of_two_sets_with_shared_elements_is_a_set_of_the_shared_elements
     skip
     set1 = CustomSet.new [1, 2, 3, 4]

data/tracks/ruby/exercises/diamond/diamond_test.rb

@@ -1,4 +1,3 @@
-# rubocop:disable Metrics/MethodLength
 # !/usr/bin/env ruby
 gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'

data/tracks/ruby/exercises/etl/etl_test.rb

@@ -32,7 +32,7 @@ class TransformTest < Minitest::Test
     assert_equal expected, ETL.transform(old)
   end
 
-  def test_full_dataset # rubocop:disable Metrics/MethodLength
+  def test_full_dataset
     skip
     old = {
       1 => %w(A E I O U L N R S T),

data/tracks/ruby/exercises/house/house_test.rb

@@ -3,7 +3,6 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'house'
 
-# rubocop:disable Metrics/MethodLength
 class HouseTest < Minitest::Test
   def test_rhyme
     expected = <<-RHYME

data/tracks/ruby/exercises/isogram/isogram_test.rb

@@ -4,10 +4,10 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'isogram'
 
-# Common test data version: 3dfde31
+# Common test data version: c1cb73f
 class IsogramTest < Minitest::Test
   def test_duplicates
-    
+    # skip
     string = 'duplicates'
     assert Isogram.is_isogram?(string)
   end

data/tracks/ruby/exercises/largest-series-product/example.tt

@@ -5,9 +5,6 @@ require_relative 'largest_series_product'
 
 # Test data version:
 # <%= sha1 %>
-# Rubocop directives
-# rubocop:disable Style/NumericLiterals
-# rubocop:disable Metrics/LineLength
 #
 class Seriestest < Minitest::Test<% test_cases.each do |test_case| %>
   def <%= test_case.name %><% if test_case.skipped? %>