rkoans 0.0.1 → 0.1.0

data/sig/runtime_context_command_test.rbs

@@ -0,0 +1,4 @@
+class RuntimeContextCommandTest
+  include CommandSupport
+  def test_runtime_context_can_be_selected_and_completed: -> void
+end

data/sig/selection_command_test.rbs

@@ -0,0 +1,5 @@
+class SelectionCommandTest
+  include CommandSupport
+  def test_named_exercises_are_listed_and_selection_resumes_without_losing_edits: -> void
+  def test_unknown_exercise_is_rejected_without_creating_a_workspace: -> void
+end

data/sig/session_command_test.rbs

@@ -0,0 +1,12 @@
+class SessionCommandTest
+  include FixtureSupport
+  def test_completion_is_persisted_and_restart_keeps_current_exercise: -> void
+  def test_next_advances_only_after_success_and_stops_at_the_last_exercise: -> void
+  def test_next_rechecks_edits_to_a_completed_exercise: -> void
+
+  private
+
+  def complete_next: (IO input, IO output, String directory, String id) -> String
+
+  def with_session: (String directory) { (IO input, IO output) -> untyped } -> untyped
+end

data/sig/session_edge_cases_test.rbs

@@ -0,0 +1,4 @@
+class SessionEdgeCasesTest
+  include FixtureSupport
+  def test_finishing_last_exercise_does_not_claim_skipped_exercises_are_complete: -> void
+end

data/sig/shared_rows_acceptance_test.rbs

@@ -0,0 +1,3 @@
+class SharedRowsAcceptanceTest
+  def test_shared_and_cached_rows_are_rejected: -> void
+end

data/sig/singleton_pattern_acceptance_test.rbs

@@ -0,0 +1,3 @@
+class SingletonPatternAcceptanceTest
+  def test_incorrect_fix_is_rejected: -> void
+end

data/sig/time_and_date_acceptance_test.rbs

@@ -0,0 +1,4 @@
+class TimeAndDateAcceptanceTest
+  def test_incorrect_fix_is_rejected: -> void
+  def test_rational_day_count_is_rejected: -> void
+end

data/sig/visibility_acceptance_test.rbs

@@ -0,0 +1,4 @@
+class VisibilityAcceptanceTest
+  def test_incorrect_fix_is_rejected: -> void
+  def test_protected_normalizer_is_rejected: -> void
+end

data/sig/watcher_test.rbs

@@ -0,0 +1,3 @@
+class WatcherTest
+  def test_save_burst_is_debounced_and_unchanged_contents_do_not_rerun: -> void
+end

data/solutions/about-array-assignment/about_array_assignment.rb

@@ -0,0 +1,36 @@
+# 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.
+
+# Explicit array literals match the assignment examples.
+# rubocop:disable Style/WordArray
+
+module Exercises
+  # Predicts how array values are assigned to one or several variables.
+  class AboutArrayAssignment
+    # Returns reference predictions for the assignment examples.
+    # @return [Hash<Symbol, String | Array<String> | nil>]
+    def self.koans
+      {
+        names: ['John', 'Smith'],
+        first_name: 'John',
+        last_name: 'Smith',
+        extra_first: 'John',
+        extra_last: 'Smith',
+        splat_first: 'John',
+        splat_last: ['Smith', 'III'],
+        short_first: 'Cher',
+        short_last: nil,
+        nested_first: ['Willie', 'Rae'],
+        nested_last: 'Johnson',
+        single_first: 'John',
+        swapped_first: 'Rob',
+        swapped_last: 'Roy'
+      }
+    end
+  end
+end
+
+# rubocop:enable Style/WordArray

data/solutions/about-arrays/about_arrays.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Explicit array literals preserve the introductory examples.
+# rubocop:disable Style/SymbolArray
+
+# 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.
+
+module Exercises
+  # Predicts array construction, indexing, slicing, ranges, and destructive operations.
+  class AboutArrays
+    # Returns reference predictions for the array experiments.
+    # Index and slice examples use [:peanut, :butter, :and, :jelly].
+    # @return [Hash<Symbol, Class | Integer | Symbol | Array | nil>]
+    # The answer table is data, not a sequence of operations.
+    def self.koans # rubocop:disable Metrics/MethodLength
+      {
+        empty_type: Array,
+        empty_size: 0,
+        second_literal: 2,
+        after_append: [1, 2, 333],
+        first_index: :peanut,
+        first_method: :peanut,
+        last_index: :jelly,
+        last_method: :jelly,
+        negative_last: :jelly,
+        negative_third: :butter,
+        slice_one: [:peanut],
+        slice_two: [:peanut, :butter],
+        slice_tail: [:and, :jelly],
+        slice_long_tail: [:and, :jelly],
+        slice_at_end_zero: [],
+        slice_at_end_long: [],
+        slice_beyond_end: nil,
+        range_type: Range,
+        inclusive_range: [1, 2, 3, 4, 5],
+        exclusive_range: [1, 2, 3, 4],
+        inclusive_slice: [:peanut, :butter, :and],
+        exclusive_slice: [:peanut, :butter],
+        negative_range_slice: [:and, :jelly],
+        after_push: [1, 2, :last],
+        popped_value: :last,
+        after_pop: [1, 2],
+        after_unshift: [:first, 1, 2],
+        shifted_value: :first,
+        after_shift: [1, 2]
+      }
+    end
+  end
+end
+
+# rubocop:enable Style/SymbolArray

data/solutions/about-asserts/about_asserts.rb

@@ -0,0 +1,22 @@
+# 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.
+
+module Exercises
+  # A reference implementation for comparison after completing the exercise.
+  class AboutAsserts
+    # Returns the truth values and expected sums for the introductory assertions.
+    # @return [Hash<Symbol, Boolean | Integer>]
+    def self.koans
+      {
+        truth: true,
+        with_message: true,
+        expected_value: 2,
+        better_expected_value: 2,
+        filled_value: 2
+      }
+    end
+  end
+end

data/solutions/about-blocks/about_blocks.rb

@@ -0,0 +1,30 @@
+# 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.
+
+module Exercises
+  # Predictions for blocks examples.
+  class AboutBlocks
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        methods_can_take_blocks_one: 3,
+        blocks_can_be_defined_with_do_end_too_one: 3,
+        blocks_can_take_arguments_one: 'Jim',
+        methods_can_call_yield_many_times_one: %i[peanut butter and jelly],
+        methods_can_see_if_they_have_been_called_with_a_block_one: :with_block,
+        methods_can_see_if_they_have_been_called_with_a_block_two: :no_block,
+        block_can_affect_variables_in_the_code_where_they_are_created_one: :modified_in_a_block,
+        blocks_can_be_assigned_to_variables_and_called_explicitly_one: 11,
+        blocks_can_be_assigned_to_variables_and_called_explicitly_two: 11,
+        stand_alone_blocks_can_be_passed_to_methods_expecting_blocks_one: 'JIM',
+        methods_can_take_an_explicit_block_argument_one: 20,
+        methods_can_take_an_explicit_block_argument_two: 11
+      }
+    end
+  end
+end

data/solutions/about-class-methods/about_class_methods.rb

@@ -0,0 +1,36 @@
+# 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.
+
+module Exercises
+  # Predictions for class methods examples.
+  class AboutClassMethods
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        objects_are_objects_one: true,
+        classes_are_classes_one: true,
+        classes_are_objects_too_one: true,
+        objects_have_methods_one: true,
+        classes_have_methods_one: true,
+        you_can_define_methods_on_individual_objects_one: :fidos_wag,
+        other_objects_are_not_affected_by_these_singleton_methods_one: ::NoMethodError,
+        since_classes_are_objects_you_can_define_singleton_methods_on_them_too_one: :class_level_wag,
+        class_methods_are_independent_of_instance_methods_one: :instance_level_wag,
+        class_methods_are_independent_of_instance_methods_two: :class_level_wag,
+        classes_and_instances_do_not_share_instance_variables_one: 'Fido',
+        classes_and_instances_do_not_share_instance_variables_two: nil,
+        you_can_define_class_methods_inside_the_class_one: :dogs_class_method,
+        class_statements_return_the_value_of_their_last_expression_one: 21,
+        self_while_inside_class_is_class_object_not_instance_one: true,
+        you_can_use_self_instead_of_an_explicit_reference_to_dog_one: :another_way_to_write_class_methods,
+        heres_still_another_way_to_write_class_methods_one: :still_another_way,
+        heres_an_easy_way_to_call_class_methods_from_instance_methods_one: :still_another_way
+      }
+    end
+  end
+end

data/solutions/about-classes/about_classes.rb

@@ -0,0 +1,40 @@
+# 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.
+
+module Exercises
+  # Predictions for classes examples.
+  class AboutClasses
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans # rubocop:disable Metrics/MethodLength
+      {
+        instances_of_classes_can_be_created_with_new_one: ::AboutClassesTest::Dog,
+        instance_variables_can_be_set_by_assigning_to_them_one: [],
+        instance_variables_can_be_set_by_assigning_to_them_two: [:@name],
+        instance_variables_cannot_be_accessed_outside_the_class_one: ::NoMethodError,
+        instance_variables_cannot_be_accessed_outside_the_class_two: ::SyntaxError,
+        you_can_politely_ask_for_instance_variable_values_one: 'Fido',
+        you_can_rip_the_value_out_using_instance_eval_one: 'Fido',
+        you_can_rip_the_value_out_using_instance_eval_two: 'Fido',
+        you_can_create_accessor_methods_to_return_instance_variables_one: 'Fido',
+        attr_reader_will_automatically_define_an_accessor_one: 'Fido',
+        attr_accessor_will_automatically_define_both_read_and_write_accessors_one: 'Fido',
+        initialize_provides_initial_values_for_instance_variables_one: 'Fido',
+        args_to_new_must_match_initialize_one: ::ArgumentError,
+        different_objects_have_different_instance_variables_one: true,
+        inside_a_method_self_refers_to_the_containing_object_one: true,
+        to_s_provides_a_string_version_of_the_object_one: 'Fido',
+        to_s_is_used_in_string_interpolation_one: 'My dog is Fido',
+        inspect_provides_a_more_complete_string_version_one: "<Dog named 'Fido'>",
+        all_objects_support_to_s_and_inspect_one: '[1, 2, 3]',
+        all_objects_support_to_s_and_inspect_two: '[1, 2, 3]',
+        all_objects_support_to_s_and_inspect_three: 'STRING',
+        all_objects_support_to_s_and_inspect_four: '"STRING"'
+      }
+    end
+  end
+end

data/solutions/about-constants/about_constants.rb

@@ -0,0 +1,26 @@
+# 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.
+
+module Exercises
+  # Predictions for constants examples.
+  class AboutConstants
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        nested_constants_may_also_be_referenced_with_relative_paths_one: 'nested',
+        top_level_constants_are_referenced_by_double_colons_one: 'top level',
+        nested_constants_are_referenced_by_their_complete_path_one: 'nested',
+        nested_constants_are_referenced_by_their_complete_path_two: 'nested',
+        nested_classes_inherit_constants_from_enclosing_classes_one: 4,
+        subclasses_inherit_constants_from_parent_classes_one: 4,
+        who_wins_with_both_nested_and_inherited_constants_one: 2,
+        who_wins_with_explicit_scoping_on_class_definition_one: 4
+      }
+    end
+  end
+end

data/solutions/about-control-statements/about_control_statements.rb

@@ -0,0 +1,35 @@
+# 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.
+
+module Exercises
+  # Predictions for control statements examples.
+  class AboutControlStatements
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        if_then_else_statements_one: :true_value,
+        if_then_statements_one: :true_value,
+        if_statements_return_values_one: :true_value,
+        if_statements_return_values_two: :false_value,
+        if_statements_with_no_else_with_false_condition_return_value_one: nil,
+        condition_operators_one: :true_value,
+        condition_operators_two: :false_value,
+        if_statement_modifiers_one: :true_value,
+        unless_statement_one: :false_value,
+        unless_statement_evaluate_true_one: :default_value,
+        unless_statement_modifier_one: :false_value,
+        while_statement_one: 3_628_800,
+        break_statement_one: 3_628_800,
+        break_statement_returns_values_one: 2,
+        next_statement_one: [1, 3, 5, 7, 9],
+        for_statement_one: %w[FISH AND CHIPS],
+        times_statement_one: 10
+      }
+    end
+  end
+end

data/solutions/about-dice-project/about_dice_project.rb

@@ -0,0 +1,27 @@
+# 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.
+
+module Exercises
+  # A set of dice with stable values until the next roll.
+  class AboutDiceProject
+    # Stores the latest roll from an injectable random source.
+    class DiceSet
+      attr_reader :values
+
+      # @param random [Random] source of uniform six-sided die values
+      def initialize(random: Random.new)
+        @random = random
+        @values = []
+      end
+
+      # @param count [Integer] number of dice to roll
+      # @return [Array<Integer>] freshly rolled values
+      def roll(count)
+        @values = Array.new(count) { @random.rand(1..6) }
+      end
+    end
+  end
+end

data/solutions/about-exceptions/about_exceptions.rb

@@ -0,0 +1,30 @@
+# 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.
+
+module Exercises
+  # Predictions for exceptions examples.
+  class AboutExceptions
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        exceptions_inherit_from_Exception_one: ::RuntimeError,
+        exceptions_inherit_from_Exception_two: ::StandardError,
+        exceptions_inherit_from_Exception_three: ::Exception,
+        exceptions_inherit_from_Exception_four: ::Object,
+        rescue_clause_one: :exception_handled,
+        rescue_clause_two: true,
+        rescue_clause_three: true,
+        rescue_clause_four: 'Oops',
+        raising_a_particular_error_one: :exception_handled,
+        raising_a_particular_error_two: 'My Message',
+        ensure_clause_one: :always_run,
+        asserting_an_error_is_raised_one: ::AboutExceptionsTest::MySpecialError
+      }
+    end
+  end
+end

data/solutions/about-extra-credit/about_extra_credit.rb

@@ -0,0 +1,114 @@
+# 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.
+
+module Exercises
+  # A deterministic Greed game engine; callers supply rolls and decide when to bank.
+  class AboutExtraCredit
+    # Tracks one player and the entry threshold.
+    class Player
+      attr_reader :name, :score
+
+      # @param name [String] player name
+      def initialize(name)
+        @name = name
+        @score = 0
+      end
+
+      # Bank a turn once the player has entered with at least 300 points.
+      # @return [Integer] total score
+      def bank(points)
+        @score += points if @score.positive? || points >= 300
+        @score
+      end
+    end
+
+    # Coordinates turn order, banking, busts and the final round.
+    class Game
+      attr_reader :players, :current
+
+      # @param names [Array<String>] at least two players, in turn order
+      def initialize(names)
+        raise ArgumentError, 'at least two players required' if names.size < 2
+
+        @players = names.map { |name| Player.new(name) }
+        @current = 0
+        @remaining = nil
+      end
+
+      # Play the current player's complete turn; ending the rolls banks the points.
+      # @param rolls [Array<Array<Integer>>] ordered rolls, with legal remaining-dice counts
+      # @return [Integer] that player's total score after this turn
+      def play_turn(rolls)
+        raise 'game finished' if finished?
+
+        total = players[current].bank(turn_points(rolls))
+        advance(total)
+        total
+      end
+
+      # @return [Boolean] all other players have taken their final turn
+      def finished?
+        @remaining&.zero? || false
+      end
+
+      # @return [Player, nil] highest-scoring player after the final round; first in a tie
+      def winner
+        players.max_by(&:score) if finished?
+      end
+
+      private
+
+      # @return [Integer] accumulated turn points, or zero after a bust
+      def turn_points(rolls)
+        raise ArgumentError, 'a turn needs at least one roll' if rolls.empty?
+
+        points = 0
+        count = 5
+        rolls.each_with_index do |roll, index|
+          validate_roll(roll, count)
+          scored, unused = score_roll(roll)
+          if scored.zero?
+            raise ArgumentError, 'turn ends on a bust' unless index == rolls.size - 1
+
+            return 0
+          end
+          points += scored
+          count = unused.zero? ? 5 : unused
+        end
+        points
+      end
+
+      # @return [void] reject malformed rolls before changing game state
+      def validate_roll(roll, count)
+        valid = roll.size == count && roll.all? { |face| face.is_a?(Integer) && (1..6).cover?(face) }
+        raise ArgumentError, 'invalid dice count or face' unless valid
+      end
+
+      # @return [Array<Integer>] points and the number of non-scoring dice
+      def score_roll(roll)
+        points = 0
+        unused = 0
+        roll.tally.each do |face, amount|
+          triples, singles = amount.divmod(3)
+          points += triples * (face == 1 ? 1000 : face * 100)
+          points += singles * { 1 => 100, 5 => 50 }.fetch(face, 0)
+          unused += singles unless [1, 5].include?(face)
+        end
+        [points, unused]
+      end
+
+      # Start the final round once, then give each remaining player exactly one turn.
+      def advance(total)
+        if @remaining
+          @remaining -= 1
+        elsif total >= 3000
+          @remaining = players.size - 1
+        end
+        @current = (current + 1) % players.size
+      end
+    end
+  end
+end

data/solutions/about-hashes/about_hashes.rb

@@ -0,0 +1,52 @@
+# 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.
+
+module Exercises
+  # Predictions for hashes examples.
+  class AboutHashes
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans # rubocop:disable Metrics/MethodLength
+      {
+        creating_hashes_one: ::Hash,
+        creating_hashes_two: {},
+        creating_hashes_three: 0,
+        hash_literals_one: 2,
+        accessing_hashes_one: 'uno',
+        accessing_hashes_two: 'dos',
+        accessing_hashes_three: nil,
+        accessing_hashes_with_fetch_one: 'uno',
+        accessing_hashes_with_fetch_two: ::KeyError,
+        changing_hashes_one: { one: 'eins', two: 'dos' },
+        hash_is_unordered_one: true,
+        hash_keys_one: 2,
+        hash_keys_two: true,
+        hash_keys_three: true,
+        hash_keys_four: ::Array,
+        hash_values_one: 2,
+        hash_values_two: true,
+        hash_values_three: true,
+        hash_values_four: ::Array,
+        combining_hashes_one: true,
+        combining_hashes_two: true,
+        default_value_one: 1,
+        default_value_two: nil,
+        default_value_three: 1,
+        default_value_four: 'dos',
+        default_value_is_the_same_object_one: %w[uno dos],
+        default_value_is_the_same_object_two: %w[uno dos],
+        default_value_is_the_same_object_three: %w[uno dos],
+        default_value_is_the_same_object_four: true,
+        default_value_with_block_one: ['uno'],
+        default_value_with_block_two: ['dos'],
+        default_value_with_block_three: [],
+        default_value_attribute_one: nil,
+        default_value_attribute_two: 'peanut'
+      }
+    end
+  end
+end

data/solutions/about-inheritance/about_inheritance.rb

@@ -0,0 +1,27 @@
+# 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.
+
+module Exercises
+  # Predictions for inheritance examples.
+  class AboutInheritance
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        subclasses_have_the_parent_as_an_ancestor_one: true,
+        all_classes_ultimately_inherit_from_object_one: true,
+        subclasses_inherit_behavior_from_parent_class_one: 'Chico',
+        subclasses_add_new_behavior_one: :happy,
+        subclasses_add_new_behavior_two: ::NoMethodError,
+        subclasses_can_modify_existing_behavior_one: 'yip',
+        subclasses_can_modify_existing_behavior_two: 'WOOF',
+        subclasses_can_invoke_parent_behavior_via_super_one: 'WOOF, GROWL',
+        super_does_not_work_cross_method_one: ::NoMethodError
+      }
+    end
+  end
+end

data/solutions/about-iteration/about_iteration.rb

@@ -0,0 +1,31 @@
+# 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.
+
+module Exercises
+  # Predictions for iteration examples.
+  class AboutIteration
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        each_is_a_method_on_arrays_one: true,
+        iterating_with_each_one: 6,
+        each_can_use_curly_brace_blocks_too_one: 6,
+        break_works_with_each_style_iterations_one: 6,
+        collect_transforms_elements_of_an_array_one: [11, 12, 13],
+        collect_transforms_elements_of_an_array_two: [11, 12, 13],
+        select_selects_certain_items_from_an_array_one: [2, 4, 6],
+        select_selects_certain_items_from_an_array_two: [2, 4, 6],
+        find_locates_the_first_element_matching_a_criteria_one: 'Clarence',
+        inject_will_blow_your_mind_one: 9,
+        inject_will_blow_your_mind_two: 24,
+        all_iteration_methods_work_on_any_collection_not_just_arrays_one: [11, 12, 13],
+        all_iteration_methods_work_on_any_collection_not_just_arrays_two: %w[THIS IS A TEST]
+      }
+    end
+  end
+end

data/solutions/about-keyword-arguments/about_keyword_arguments.rb

@@ -0,0 +1,28 @@
+# 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.
+
+module Exercises
+  # Predictions for keyword arguments examples.
+  class AboutKeywordArguments
+    # Returns reference predictions for the examples.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        keyword_arguments_one: ::Array,
+        keyword_arguments_two: [1, 'two'],
+        keyword_arguments_three: %w[one two],
+        keyword_arguments_four: [1, 2],
+        keyword_arguments_with_wrong_number_of_arguments_one: ::ArgumentError,
+        keyword_arguments_with_wrong_number_of_arguments_two: 'wrong number of arguments',
+        mandatory_keyword_arguments_one: %w[one two],
+        mandatory_keyword_arguments_two: [1, 2],
+        mandatory_keyword_arguments_without_mandatory_argument_one: ::ArgumentError,
+        mandatory_keyword_arguments_without_mandatory_argument_two: 'missing keyword'
+      }
+    end
+  end
+end