rkoans 0.0.1 → 0.1.0

data/test/exercises/about_extra_credit_test.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+require ARGV.shift
+
+class AboutExtraCreditTest < Minitest::Test
+  # Entry requires 300 in one turn; after entry, smaller turns count too.
+  def test_entry_threshold_and_later_banking
+    player = Exercises::AboutExtraCredit::Player.new('Ruby')
+
+    assert_equal 0, player.bank(250)
+    assert_equal 300, player.bank(300)
+    assert_equal 350, player.bank(50)
+  end
+
+  # A zero-scoring roll forfeits this turn, but leaves earlier banked points intact.
+  def test_bust_discards_the_entire_turn
+    game = Exercises::AboutExtraCredit::Game.new(%w[Ruby Ada])
+
+    assert_equal 350, game.play_turn([[1, 5, 2, 3, 4], [2, 2, 2]])
+    assert_equal 0, game.play_turn([[2, 3, 4, 6, 2]])
+    assert_equal 350, game.play_turn([[1, 5, 2, 3, 4], [2, 3, 4]])
+  end
+
+  # All scoring dice allow five fresh dice; otherwise only non-scoring dice reroll.
+  def test_hot_dice_and_roll_validation
+    game = Exercises::AboutExtraCredit::Game.new(%w[Ruby Ada])
+
+    assert_equal 2400, game.play_turn([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1]])
+    assert_raises(ArgumentError) { game.play_turn([[1, 5, 2, 3, 4], [1, 1, 1, 1, 1]]) }
+    assert_raises(ArgumentError) { game.play_turn([[0, 1, 2, 3, 4]]) }
+    assert_raises(ArgumentError) { game.play_turn([[1.0, 1, 2, 3, 4]]) }
+    assert_raises(ArgumentError) { game.play_turn([]) }
+    assert_raises(ArgumentError) { game.play_turn([[2, 3, 4, 6, 2], [1, 1, 1, 1, 1]]) }
+    assert_equal 1, game.current
+    assert_equal [2400, 0], game.players.map(&:score)
+  end
+
+  # A leader starts one final round, even if a later player overtakes the leader.
+  def test_every_other_player_gets_one_final_turn
+    game = Exercises::AboutExtraCredit::Game.new(%w[Ruby Ada Matz])
+    all_ones = [1, 1, 1, 1, 1]
+
+    assert_equal 3600, game.play_turn([all_ones, all_ones, all_ones])
+    refute_predicate game, :finished?
+    assert_nil game.winner
+    assert_equal 4800, game.play_turn([all_ones, all_ones, all_ones, all_ones])
+    refute_predicate game, :finished?
+    assert_equal 0, game.play_turn([[2, 3, 4, 6, 2]])
+    assert_predicate game, :finished?
+    assert_equal 'Ada', game.winner.name
+    assert_raises(RuntimeError) { game.play_turn([all_ones]) }
+    assert_raises(ArgumentError) { Exercises::AboutExtraCredit::Game.new(['solo']) }
+  end
+
+  # Exactly 3000 starts the final round; the remaining turns wrap around the order.
+  def test_final_round_starts_at_3000_and_wraps_turn_order
+    game = Exercises::AboutExtraCredit::Game.new(%w[Ruby Ada Matz])
+    all_ones = [1, 1, 1, 1, 1]
+    threshold = [all_ones, all_ones, [6, 6, 6, 2, 3]]
+    game.play_turn([[2, 3, 4, 6, 2]])
+
+    assert_equal 3000, game.play_turn(threshold)
+    refute_predicate game, :finished?
+    assert_equal 0, game.play_turn([[2, 3, 4, 6, 2]])
+    refute_predicate game, :finished?
+    assert_equal 3000, game.play_turn(threshold)
+    assert_predicate game, :finished?
+    assert_equal 'Ruby', game.winner.name
+  end
+end

data/test/exercises/about_hashes_test.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# Constructor and shared-default examples are deliberate observations.
+# rubocop:disable Lint/SharedMutableDefault, Style/EmptyLiteral
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+require ARGV.shift
+class AboutHashesTest < Minitest::Test
+  # Checks creating hashes.
+  def test_creating_hashes
+    empty_hash = Hash.new
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:creating_hashes_one), empty_hash.class
+    assert_equal Exercises::AboutHashes.koans.fetch(:creating_hashes_two), empty_hash
+    assert_equal Exercises::AboutHashes.koans.fetch(:creating_hashes_three), empty_hash.size
+  end
+
+  # Checks hash literals.
+  def test_hash_literals
+    hash = { one: 'uno', two: 'dos' }
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_literals_one), hash.size
+  end
+
+  # Checks accessing hashes.
+  def test_accessing_hashes
+    hash = { one: 'uno', two: 'dos' }
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:accessing_hashes_one), hash[:one]
+    assert_equal Exercises::AboutHashes.koans.fetch(:accessing_hashes_two), hash[:two]
+    assert_equal Exercises::AboutHashes.koans.fetch(:accessing_hashes_three), hash[:doesnt_exist]
+  end
+
+  # Checks accessing hashes with fetch.
+  def test_accessing_hashes_with_fetch
+    hash = { one: 'uno' }
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:accessing_hashes_with_fetch_one), hash.fetch(:one)
+    assert_predicted_error(:accessing_hashes_with_fetch_two, ::KeyError) do
+      hash.fetch(:doesnt_exist)
+    end
+
+    # THINK ABOUT IT:
+    #
+    # Why might you want to use #fetch instead of #[] when accessing hash keys?
+  end
+
+  # Checks changing hashes.
+  def test_changing_hashes
+    hash = { one: 'uno', two: 'dos' }
+    hash[:one] = 'eins'
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:changing_hashes_one), hash
+  end
+
+  # Checks hash is unordered.
+  def test_hash_is_unordered
+    hash1 = { one: 'uno', two: 'dos' }
+    hash2 = { two: 'dos', one: 'uno' }
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_is_unordered_one), (hash1 == hash2)
+  end
+
+  # Checks hash keys.
+  def test_hash_keys
+    hash = { one: 'uno', two: 'dos' }
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_keys_one), hash.keys.size
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_keys_two), hash.keys.include?(:one)
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_keys_three), hash.keys.include?(:two)
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_keys_four), hash.keys.class
+  end
+
+  # Checks hash values.
+  def test_hash_values
+    hash = { one: 'uno', two: 'dos' }
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_values_one), hash.values.size
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_values_two), hash.values.include?('uno')
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_values_three), hash.values.include?('dos')
+    assert_equal Exercises::AboutHashes.koans.fetch(:hash_values_four), hash.values.class
+  end
+
+  # Checks combining hashes.
+  def test_combining_hashes
+    hash = { 'jim' => 53, 'amy' => 20, 'dan' => 23 }
+    new_hash = hash.merge({ 'jim' => 54, 'jenny' => 26 })
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:combining_hashes_one), (hash != new_hash)
+
+    expected = { 'jim' => 54, 'amy' => 20, 'dan' => 23, 'jenny' => 26 }
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:combining_hashes_two), (expected == new_hash)
+  end
+
+  # Checks default value.
+  def test_default_value
+    hash1 = Hash.new
+    hash1[:one] = 1
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_one), hash1[:one]
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_two), hash1[:two]
+
+    hash2 = Hash.new('dos')
+    hash2[:one] = 1
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_three), hash2[:one]
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_four), hash2[:two]
+  end
+
+  # Checks default value is the same object.
+  def test_default_value_is_the_same_object
+    hash = Hash.new([])
+
+    hash[:one] << 'uno'
+    hash[:two] << 'dos'
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_is_the_same_object_one), hash[:one]
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_is_the_same_object_two), hash[:two]
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_is_the_same_object_three), hash[:three]
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_is_the_same_object_four),
+                 hash[:one].equal?(hash[:two])
+  end
+
+  # Checks default value with block.
+  def test_default_value_with_block
+    hash = Hash.new { |hash, key| hash[key] = [] }
+
+    hash[:one] << 'uno'
+    hash[:two] << 'dos'
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_with_block_one), hash[:one]
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_with_block_two), hash[:two]
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_with_block_three), hash[:three]
+  end
+
+  # Checks default value attribute.
+  def test_default_value_attribute
+    hash = Hash.new
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_attribute_one), hash[:some_key]
+
+    hash.default = 'peanut'
+
+    assert_equal Exercises::AboutHashes.koans.fetch(:default_value_attribute_two), hash[:some_key]
+  end
+
+  # Checks the predicted exception class while returning the captured error.
+  # @param key [Symbol] answer field
+  # @param klass [Class<Exception>] exception raised by the example
+  # @return [Exception]
+  def assert_predicted_error(key, ...)
+    error = assert_raises(...)
+    assert_equal Exercises::AboutHashes.koans.fetch(key), error.class
+    error
+  end
+end
+
+# rubocop:enable Lint/SharedMutableDefault, Style/EmptyLiteral

data/test/exercises/about_inheritance_test.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+require ARGV.shift
+class AboutInheritanceTest < Minitest::Test
+  class Dog
+    attr_reader :name
+
+    # Demonstrates initialize.
+    def initialize(name)
+      @name = name
+    end
+
+    # Demonstrates bark.
+    def bark
+      'WOOF'
+    end
+  end
+
+  class Chihuahua < Dog
+    # Demonstrates wag.
+    def wag
+      :happy
+    end
+
+    # Demonstrates bark.
+    def bark
+      'yip'
+    end
+  end
+
+  # Checks subclasses have the parent as an ancestor.
+  def test_subclasses_have_the_parent_as_an_ancestor
+    assert_equal Exercises::AboutInheritance.koans.fetch(:subclasses_have_the_parent_as_an_ancestor_one),
+                 Chihuahua.ancestors.include?(Dog)
+  end
+
+  # Checks all classes ultimately inherit from object.
+  def test_all_classes_ultimately_inherit_from_object
+    assert_equal Exercises::AboutInheritance.koans.fetch(:all_classes_ultimately_inherit_from_object_one),
+                 Chihuahua.ancestors.include?(Object)
+  end
+
+  # Checks subclasses inherit behavior from parent class.
+  def test_subclasses_inherit_behavior_from_parent_class
+    chico = Chihuahua.new('Chico')
+
+    assert_equal Exercises::AboutInheritance.koans.fetch(:subclasses_inherit_behavior_from_parent_class_one),
+                 chico.name
+  end
+
+  # Checks subclasses add new behavior.
+  def test_subclasses_add_new_behavior
+    chico = Chihuahua.new('Chico')
+
+    assert_equal Exercises::AboutInheritance.koans.fetch(:subclasses_add_new_behavior_one), chico.wag
+
+    assert_predicted_error(:subclasses_add_new_behavior_two, ::NoMethodError) do
+      fido = Dog.new('Fido')
+      fido.wag
+    end
+  end
+
+  # Checks subclasses can modify existing behavior.
+  def test_subclasses_can_modify_existing_behavior
+    chico = Chihuahua.new('Chico')
+
+    assert_equal Exercises::AboutInheritance.koans.fetch(:subclasses_can_modify_existing_behavior_one), chico.bark
+
+    fido = Dog.new('Fido')
+
+    assert_equal Exercises::AboutInheritance.koans.fetch(:subclasses_can_modify_existing_behavior_two), fido.bark
+  end
+
+  # ------------------------------------------------------------------
+
+  class BullDog < Dog
+    # Demonstrates bark.
+    def bark
+      "#{super}, GROWL"
+    end
+  end
+
+  # Checks subclasses can invoke parent behavior via super.
+  def test_subclasses_can_invoke_parent_behavior_via_super
+    ralph = BullDog.new('Ralph')
+
+    assert_equal Exercises::AboutInheritance.koans.fetch(:subclasses_can_invoke_parent_behavior_via_super_one),
+                 ralph.bark
+  end
+
+  # ------------------------------------------------------------------
+
+  class GreatDane < Dog
+    # Demonstrates growl.
+    def growl
+      "#{super.bark}, GROWL"
+    end
+  end
+
+  # Checks super does not work cross method.
+  def test_super_does_not_work_cross_method
+    george = GreatDane.new('George')
+    assert_predicted_error(:super_does_not_work_cross_method_one, ::NoMethodError) do
+      george.growl
+    end
+  end
+
+  # Checks the predicted exception class while returning the captured error.
+  # @param key [Symbol] answer field
+  # @param klass [Class<Exception>] exception raised by the example
+  # @return [Exception]
+  def assert_predicted_error(key, ...)
+    error = assert_raises(...)
+    assert_equal Exercises::AboutInheritance.koans.fetch(key), error.class
+    error
+  end
+end

data/test/exercises/about_iteration_test.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+# Preserve the explicit block forms being taught.
+# rubocop:disable Style/SymbolProc
+
+require ARGV.shift
+require 'tempfile'
+
+class AboutIterationTest < Minitest::Test
+  # Checks each is a method on arrays.
+  def test_each_is_a_method_on_arrays
+    assert_equal Exercises::AboutIteration.koans.fetch(:each_is_a_method_on_arrays_one), [].methods.include?(:each)
+  end
+
+  # Checks iterating with each.
+  def test_iterating_with_each
+    array = [1, 2, 3]
+    sum = 0
+    array.each do |item|
+      sum += item
+    end
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:iterating_with_each_one), sum
+  end
+
+  # Checks each can use curly brace blocks too.
+  def test_each_can_use_curly_brace_blocks_too
+    array = [1, 2, 3]
+    sum = 0
+    array.each { |item| sum += item }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:each_can_use_curly_brace_blocks_too_one), sum
+  end
+
+  # Checks break works with each style iterations.
+  def test_break_works_with_each_style_iterations
+    array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    sum = 0
+    array.each do |item|
+      break if item > 3
+
+      sum += item
+    end
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:break_works_with_each_style_iterations_one), sum
+  end
+
+  # Checks collect transforms elements of an array.
+  def test_collect_transforms_elements_of_an_array
+    array = [1, 2, 3]
+    new_array = array.collect { |item| item + 10 }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:collect_transforms_elements_of_an_array_one), new_array
+
+    # NOTE: 'map' is another name for the 'collect' operation
+    another_array = array.map { |item| item + 10 }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:collect_transforms_elements_of_an_array_two), another_array
+  end
+
+  # Checks select selects certain items from an array.
+  def test_select_selects_certain_items_from_an_array
+    array = [1, 2, 3, 4, 5, 6]
+
+    even_numbers = array.select { |item| item.even? }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:select_selects_certain_items_from_an_array_one), even_numbers
+
+    # NOTE: 'find_all' is another name for the 'select' operation
+    more_even_numbers = array.find_all { |item| item.even? }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:select_selects_certain_items_from_an_array_two),
+                 more_even_numbers
+  end
+
+  # Checks find locates the first element matching a criteria.
+  def test_find_locates_the_first_element_matching_a_criteria
+    array = %w[Jim Bill Clarence Doug Eli]
+
+    found = array.find { |item| item.size > 4 }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:find_locates_the_first_element_matching_a_criteria_one), found
+  end
+
+  # Checks inject will blow your mind.
+  def test_inject_will_blow_your_mind
+    result = [2, 3, 4].inject(0) { |sum, item| sum + item }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:inject_will_blow_your_mind_one), result
+
+    result2 = [2, 3, 4].inject(1) { |product, item| product * item }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:inject_will_blow_your_mind_two), result2
+
+    # Extra Credit:
+    # Describe in your own words what inject does.
+  end
+
+  # Checks all iteration methods work on any collection not just arrays.
+  def test_all_iteration_methods_work_on_any_collection_not_just_arrays
+    # Ranges act like a collection
+    result = (1..3).map { |item| item + 10 }
+
+    assert_equal Exercises::AboutIteration.koans.fetch(:all_iteration_methods_work_on_any_collection_not_just_arrays_one),
+                 result
+
+    # Files act like a collection of lines
+    with_example_file do |file|
+      upcase_lines = file.map { |line| line.strip.upcase }
+
+      assert_equal Exercises::AboutIteration.koans.fetch(:all_iteration_methods_work_on_any_collection_not_just_arrays_two),
+                   upcase_lines
+    end
+
+    # NOTE: You can create your own collections that work with each,
+    # map, select, etc.
+  end
+
+  # Bonus Question:  In the previous koan, we saw the construct:
+  #
+  #   File.open(filename) do |file|
+  #     # code to read 'file'
+  #   end
+  #
+  # Why did we do it that way instead of the following?
+  #
+  #   file = File.open(filename)
+  #   # code to read 'file'
+  #
+  # When you get to the "AboutSandwichCode" koan, recheck your answer.
+
+  # Supplies the original four-line example without relying on the working directory.
+  # @yieldparam file [File] rewound example file
+  # @return [Object] block result
+  def with_example_file
+    Tempfile.create('rkoans-iteration') do |file|
+      file.write("this\nis\na\ntest\n")
+      file.rewind
+      yield file
+    end
+  end
+end
+
+# rubocop:enable Style/SymbolProc

data/test/exercises/about_keyword_arguments_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: CC-BY-NC-SA-3.0
+# Adapted from Ruby Koans by Jim Weirich and Joe O'Brien.
+# See THIRD_PARTY_NOTICES.md for attribution and license terms.
+
+require ARGV.shift
+class AboutKeywordArgumentsTest < Minitest::Test
+  # Demonstrates method with keyword arguments.
+  def method_with_keyword_arguments(one: 1, two: 'two')
+    [one, two]
+  end
+
+  # Checks keyword arguments.
+  def test_keyword_arguments
+    assert_equal Exercises::AboutKeywordArguments.koans.fetch(:keyword_arguments_one),
+                 method_with_keyword_arguments.class
+    assert_equal Exercises::AboutKeywordArguments.koans.fetch(:keyword_arguments_two), method_with_keyword_arguments
+    assert_equal Exercises::AboutKeywordArguments.koans.fetch(:keyword_arguments_three),
+                 method_with_keyword_arguments(one: 'one')
+    assert_equal Exercises::AboutKeywordArguments.koans.fetch(:keyword_arguments_four),
+                 method_with_keyword_arguments(two: 2)
+  end
+
+  # Demonstrates method with keyword arguments with mandatory argument.
+  def method_with_keyword_arguments_with_mandatory_argument(one, two: 2, three: 3)
+    [one, two, three]
+  end
+
+  # Checks keyword arguments with wrong number of arguments.
+  def test_keyword_arguments_with_wrong_number_of_arguments
+    exception = assert_predicted_error(:keyword_arguments_with_wrong_number_of_arguments_one, ::ArgumentError) do
+      method_with_keyword_arguments_with_mandatory_argument
+    end
+    assert_predicted_message(:keyword_arguments_with_wrong_number_of_arguments_two, exception.message)
+  end
+
+  # Demonstrates method with mandatory keyword arguments.
+  def method_with_mandatory_keyword_arguments(one:, two: 'two')
+    [one, two]
+  end
+
+  # Checks mandatory keyword arguments.
+  def test_mandatory_keyword_arguments
+    assert_equal Exercises::AboutKeywordArguments.koans.fetch(:mandatory_keyword_arguments_one),
+                 method_with_mandatory_keyword_arguments(one: 'one')
+    assert_equal Exercises::AboutKeywordArguments.koans.fetch(:mandatory_keyword_arguments_two),
+                 method_with_mandatory_keyword_arguments(two: 2, one: 1)
+  end
+
+  # Checks mandatory keyword arguments without mandatory argument.
+  def test_mandatory_keyword_arguments_without_mandatory_argument
+    exception = assert_predicted_error(:mandatory_keyword_arguments_without_mandatory_argument_one, ::ArgumentError) do
+      method_with_mandatory_keyword_arguments
+    end
+    assert_predicted_message(:mandatory_keyword_arguments_without_mandatory_argument_two, exception.message)
+  end
+
+  # Checks the predicted exception class while returning the captured error.
+  # @param key [Symbol] answer field
+  # @param klass [Class<Exception>] exception raised by the example
+  # @return [Exception]
+  def assert_predicted_error(key, ...)
+    error = assert_raises(...)
+    assert_equal Exercises::AboutKeywordArguments.koans.fetch(key), error.class
+    error
+  end
+
+  # Checks a nonempty literal fragment without depending on full diagnostic formatting.
+  # @param key [Symbol] answer field
+  # @param message [String] observed exception message
+  # @return [void]
+  def assert_predicted_message(key, message)
+    fragment = Exercises::AboutKeywordArguments.koans.fetch(key)
+
+    assert_kind_of String, fragment
+    refute_empty fragment
+    assert_includes message, fragment
+  end
+end