rkoans 0.0.1 → 0.1.0

data/test/exercises/about_classes_test.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+# The original descriptive check identifiers and example strings remain intact.
+# An empty class demonstrates construction without custom methods.
+# Conversions deliberately compare the same protocol on different built-in objects.
+# Keep the related original chapter examples together.
+# Explicit setters are compared with generated accessors in this chapter.
+# The examples contrast block forms and their behavior.
+# The fixed literal expression is an isolated binding or syntax experiment.
+# Explicit getter definitions are compared with attr_reader and attr_accessor.
+# rubocop:disable Layout/LineLength, Lint/EmptyClass, Lint/RedundantTypeConversion, Metrics/ClassLength, Naming/AccessorMethodName, Style/BlockDelimiters, Style/EvalWithLocation, Style/TrivialAccessors
+
+# 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 AboutClassesTest < Minitest::Test
+  class Dog
+  end
+
+  # Checks instances of classes can be created with new.
+  def test_instances_of_classes_can_be_created_with_new
+    fido = Dog.new
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:instances_of_classes_can_be_created_with_new_one), fido.class
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog2
+    # Demonstrates set name.
+    def set_name(a_name)
+      @name = a_name
+    end
+  end
+
+  # Checks instance variables can be set by assigning to them.
+  def test_instance_variables_can_be_set_by_assigning_to_them
+    fido = Dog2.new
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:instance_variables_can_be_set_by_assigning_to_them_one),
+                 fido.instance_variables
+
+    fido.set_name('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:instance_variables_can_be_set_by_assigning_to_them_two),
+                 fido.instance_variables
+  end
+
+  # Checks instance variables cannot be accessed outside the class.
+  def test_instance_variables_cannot_be_accessed_outside_the_class
+    fido = Dog2.new
+    fido.set_name('Fido')
+
+    assert_predicted_error(:instance_variables_cannot_be_accessed_outside_the_class_one, ::NoMethodError) do
+      fido.name
+    end
+
+    assert_predicted_error(:instance_variables_cannot_be_accessed_outside_the_class_two, ::SyntaxError) do
+      eval 'fido.@name'
+    end
+  end
+
+  # Checks you can politely ask for instance variable values.
+  def test_you_can_politely_ask_for_instance_variable_values
+    fido = Dog2.new
+    fido.set_name('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:you_can_politely_ask_for_instance_variable_values_one),
+                 fido.instance_variable_get('@name')
+  end
+
+  # Checks you can rip the value out using instance eval.
+  def test_you_can_rip_the_value_out_using_instance_eval
+    fido = Dog2.new
+    fido.set_name('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:you_can_rip_the_value_out_using_instance_eval_one), fido.instance_eval('@name') # string version
+    assert_equal(Exercises::AboutClasses.koans.fetch(:you_can_rip_the_value_out_using_instance_eval_two), fido.instance_eval {
+      @name
+    }) # block version
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog3
+    # Demonstrates set name.
+    def set_name(a_name)
+      @name = a_name
+    end
+
+    # Demonstrates name.
+    def name
+      @name
+    end
+  end
+
+  # Checks you can create accessor methods to return instance variables.
+  def test_you_can_create_accessor_methods_to_return_instance_variables
+    fido = Dog3.new
+    fido.set_name('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:you_can_create_accessor_methods_to_return_instance_variables_one),
+                 fido.name
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog4
+    attr_reader :name
+
+    # Demonstrates set name.
+    def set_name(a_name)
+      @name = a_name
+    end
+  end
+
+  # Checks attr reader will automatically define an accessor.
+  def test_attr_reader_will_automatically_define_an_accessor
+    fido = Dog4.new
+    fido.set_name('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:attr_reader_will_automatically_define_an_accessor_one),
+                 fido.name
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog5
+    attr_accessor :name
+  end
+
+  # Checks attr accessor will automatically define both read and write accessors.
+  def test_attr_accessor_will_automatically_define_both_read_and_write_accessors
+    fido = Dog5.new
+
+    fido.name = 'Fido'
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:attr_accessor_will_automatically_define_both_read_and_write_accessors_one),
+                 fido.name
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog6
+    attr_reader :name
+
+    # Demonstrates initialize.
+    def initialize(initial_name)
+      @name = initial_name
+    end
+  end
+
+  # Checks initialize provides initial values for instance variables.
+  def test_initialize_provides_initial_values_for_instance_variables
+    fido = Dog6.new('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:initialize_provides_initial_values_for_instance_variables_one),
+                 fido.name
+  end
+
+  # Checks args to new must match initialize.
+  def test_args_to_new_must_match_initialize
+    assert_predicted_error(:args_to_new_must_match_initialize_one, ::ArgumentError) do
+      Dog6.new
+    end
+    # THINK ABOUT IT:
+    # Why is this so?
+  end
+
+  # Checks different objects have different instance variables.
+  def test_different_objects_have_different_instance_variables
+    fido = Dog6.new('Fido')
+    rover = Dog6.new('Rover')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:different_objects_have_different_instance_variables_one),
+                 (rover.name != fido.name)
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog7
+    attr_reader :name
+
+    # Demonstrates initialize.
+    def initialize(initial_name)
+      @name = initial_name
+    end
+
+    # Demonstrates get self.
+    def get_self
+      self
+    end
+
+    # Demonstrates to s.
+    def to_s
+      @name
+    end
+
+    # Demonstrates inspect.
+    def inspect
+      "<Dog named '#{name}'>"
+    end
+  end
+
+  # Checks inside a method self refers to the containing object.
+  def test_inside_a_method_self_refers_to_the_containing_object
+    fido = Dog7.new('Fido')
+
+    fidos_self = fido.get_self
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:inside_a_method_self_refers_to_the_containing_object_one),
+                 fidos_self.equal?(fido)
+  end
+
+  # Checks to s provides a string version of the object.
+  def test_to_s_provides_a_string_version_of_the_object
+    fido = Dog7.new('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:to_s_provides_a_string_version_of_the_object_one), fido.to_s
+  end
+
+  # Checks to s is used in string interpolation.
+  def test_to_s_is_used_in_string_interpolation
+    fido = Dog7.new('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:to_s_is_used_in_string_interpolation_one), "My dog is #{fido}"
+  end
+
+  # Checks inspect provides a more complete string version.
+  def test_inspect_provides_a_more_complete_string_version
+    fido = Dog7.new('Fido')
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:inspect_provides_a_more_complete_string_version_one),
+                 fido.inspect
+  end
+
+  # Checks all objects support to s and inspect.
+  def test_all_objects_support_to_s_and_inspect
+    array = [1, 2, 3]
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:all_objects_support_to_s_and_inspect_one), array.to_s
+    assert_equal Exercises::AboutClasses.koans.fetch(:all_objects_support_to_s_and_inspect_two), array.inspect
+
+    assert_equal Exercises::AboutClasses.koans.fetch(:all_objects_support_to_s_and_inspect_three), 'STRING'.to_s
+    assert_equal Exercises::AboutClasses.koans.fetch(:all_objects_support_to_s_and_inspect_four), 'STRING'.inspect
+  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::AboutClasses.koans.fetch(key), error.class
+    error
+  end
+end
+
+# rubocop:enable Layout/LineLength, Lint/EmptyClass, Lint/RedundantTypeConversion, Metrics/ClassLength, Naming/AccessorMethodName, Style/BlockDelimiters, Style/EvalWithLocation, Style/TrivialAccessors

data/test/exercises/about_constants_test.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# The explicit class path changes lexical constant lookup.
+# rubocop:disable Style/ClassAndModuleChildren
+
+# 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
+C = 'top level'
+
+class AboutConstantsTest < Minitest::Test
+  C = 'nested'
+
+  # Checks nested constants may also be referenced with relative paths.
+  def test_nested_constants_may_also_be_referenced_with_relative_paths
+    assert_equal Exercises::AboutConstants.koans.fetch(:nested_constants_may_also_be_referenced_with_relative_paths_one),
+                 C
+  end
+
+  # Checks top level constants are referenced by double colons.
+  def test_top_level_constants_are_referenced_by_double_colons
+    assert_equal Exercises::AboutConstants.koans.fetch(:top_level_constants_are_referenced_by_double_colons_one), ::C
+  end
+
+  # Checks nested constants are referenced by their complete path.
+  def test_nested_constants_are_referenced_by_their_complete_path
+    assert_equal Exercises::AboutConstants.koans.fetch(:nested_constants_are_referenced_by_their_complete_path_one), AboutConstantsTest::C
+    assert_equal Exercises::AboutConstants.koans.fetch(:nested_constants_are_referenced_by_their_complete_path_two),
+                 ::AboutConstantsTest::C
+  end
+
+  # ------------------------------------------------------------------
+
+  class Animal
+    LEGS = 4
+    # Demonstrates legs in animal.
+    def legs_in_animal
+      LEGS
+    end
+
+    class NestedAnimal
+      # Demonstrates legs in nested animal.
+      def legs_in_nested_animal
+        LEGS
+      end
+    end
+  end
+
+  # Checks nested classes inherit constants from enclosing classes.
+  def test_nested_classes_inherit_constants_from_enclosing_classes
+    assert_equal Exercises::AboutConstants.koans.fetch(:nested_classes_inherit_constants_from_enclosing_classes_one), Animal::NestedAnimal.new.legs_in_nested_animal
+  end
+
+  # ------------------------------------------------------------------
+
+  class Reptile < Animal
+    # Demonstrates legs in reptile.
+    def legs_in_reptile
+      LEGS
+    end
+  end
+
+  # Checks subclasses inherit constants from parent classes.
+  def test_subclasses_inherit_constants_from_parent_classes
+    assert_equal Exercises::AboutConstants.koans.fetch(:subclasses_inherit_constants_from_parent_classes_one),
+                 Reptile.new.legs_in_reptile
+  end
+
+  # ------------------------------------------------------------------
+
+  class MyAnimals
+    LEGS = 2
+
+    class Bird < Animal
+      # Demonstrates legs in bird.
+      def legs_in_bird
+        LEGS
+      end
+    end
+  end
+
+  # Checks who wins with both nested and inherited constants.
+  def test_who_wins_with_both_nested_and_inherited_constants
+    assert_equal Exercises::AboutConstants.koans.fetch(:who_wins_with_both_nested_and_inherited_constants_one), MyAnimals::Bird.new.legs_in_bird
+  end
+
+  # QUESTION: Which has precedence: The constant in the lexical scope,
+  # or the constant from the inheritance hierarchy?
+
+  # ------------------------------------------------------------------
+
+  class MyAnimals::Oyster < Animal
+    # Demonstrates legs in oyster.
+    def legs_in_oyster
+      LEGS
+    end
+  end
+
+  # Checks who wins with explicit scoping on class definition.
+  def test_who_wins_with_explicit_scoping_on_class_definition
+    assert_equal Exercises::AboutConstants.koans.fetch(:who_wins_with_explicit_scoping_on_class_definition_one), MyAnimals::Oyster.new.legs_in_oyster
+  end
+
+  # QUESTION: Now which has precedence: The constant in the lexical
+  # scope, or the constant from the inheritance hierarchy?  Why is it
+  # different than the previous answer?
+end
+
+# rubocop:enable Style/ClassAndModuleChildren

data/test/exercises/about_control_statements_test.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+# Literal conditions isolate the control-flow behavior being predicted.
+# Keep the related original chapter examples together.
+# Separate conditional and assignment forms are deliberately contrasted.
+# The example deliberately uses for rather than a block iterator.
+# Full conditionals distinguish statement forms from modifiers.
+# The example demonstrates break inside a while loop.
+# rubocop:disable Lint/LiteralAsCondition, Metrics/ClassLength, Style/ConditionalAssignment, Style/For, Style/IfUnlessModifier, Style/InfiniteLoop
+
+# 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 AboutControlStatementsTest < Minitest::Test
+  # Checks if then else statements.
+  def test_if_then_else_statements
+    if true
+      result = :true_value
+    else
+      result = :false_value
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:if_then_else_statements_one), result
+  end
+
+  # Checks if then statements.
+  def test_if_then_statements
+    result = :default_value
+    if true
+      result = :true_value
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:if_then_statements_one), result
+  end
+
+  # Checks if statements return values.
+  def test_if_statements_return_values
+    value = if true
+              :true_value
+            else
+              :false_value
+            end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:if_statements_return_values_one), value
+
+    value = if false
+              :true_value
+            else
+              :false_value
+            end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:if_statements_return_values_two), value
+
+    # NOTE: Actually, EVERY statement in Ruby will return a value, not
+    # just if statements.
+  end
+
+  # Checks if statements with no else with false condition return value.
+  def test_if_statements_with_no_else_with_false_condition_return_value
+    value = if false
+              :true_value
+            end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:if_statements_with_no_else_with_false_condition_return_value_one),
+                 value
+  end
+
+  # Checks condition operators.
+  def test_condition_operators
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:condition_operators_one),
+                 ((true ? :true_value : :false_value))
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:condition_operators_two),
+                 ((false ? :true_value : :false_value))
+  end
+
+  # Checks if statement modifiers.
+  def test_if_statement_modifiers
+    result = :default_value
+    result = :true_value if true
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:if_statement_modifiers_one), result
+  end
+
+  # Checks unless statement.
+  def test_unless_statement
+    result = :default_value
+    unless false # same as saying 'if !false', which evaluates as 'if true'
+      result = :false_value
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:unless_statement_one), result
+  end
+
+  # Checks unless statement evaluate true.
+  def test_unless_statement_evaluate_true
+    result = :default_value
+    unless true # same as saying 'if !true', which evaluates as 'if false'
+      result = :true_value
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:unless_statement_evaluate_true_one), result
+  end
+
+  # Checks unless statement modifier.
+  def test_unless_statement_modifier
+    result = :default_value
+    result = :false_value unless false
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:unless_statement_modifier_one), result
+  end
+
+  # Checks while statement.
+  def test_while_statement
+    i = 1
+    result = 1
+    while i <= 10
+      result *= i
+      i += 1
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:while_statement_one), result
+  end
+
+  # Checks break statement.
+  def test_break_statement
+    i = 1
+    result = 1
+    while true
+      break unless i <= 10
+
+      result *= i
+      i += 1
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:break_statement_one), result
+  end
+
+  # Checks break statement returns values.
+  def test_break_statement_returns_values
+    i = 1
+    result = while i <= 10
+               break i if i.even?
+
+               i += 1
+             end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:break_statement_returns_values_one), result
+  end
+
+  # Checks next statement.
+  def test_next_statement
+    i = 0
+    result = []
+    while i < 10
+      i += 1
+      next if i.even?
+
+      result << i
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:next_statement_one), result
+  end
+
+  # Checks for statement.
+  def test_for_statement
+    array = %w[fish and chips]
+    result = []
+    for item in array
+      result << item.upcase
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:for_statement_one), result
+  end
+
+  # Checks times statement.
+  def test_times_statement
+    sum = 0
+    10.times do
+      sum += 1
+    end
+
+    assert_equal Exercises::AboutControlStatements.koans.fetch(:times_statement_one), sum
+  end
+end
+
+# rubocop:enable Lint/LiteralAsCondition, Metrics/ClassLength, Style/ConditionalAssignment, Style/For, Style/IfUnlessModifier, Style/InfiniteLoop

data/test/exercises/about_dice_project_test.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.
+
+require ARGV.shift
+
+class AboutDiceProjectTest < Minitest::Test
+  # A new set is empty and can roll different counts without accumulating old dice.
+  def test_can_create_and_resize_a_dice_set
+    dice = Exercises::AboutDiceProject::DiceSet.new(random: Random.new(12))
+
+    assert_empty dice.values
+    [5, 3, 1, 0].each do |count|
+      dice.roll(count)
+
+      assert_equal count, dice.values.size
+      values = dice.values
+      values.each do |value|
+        assert_instance_of Integer, value
+        assert_includes 1..6, value
+      end
+    end
+  end
+
+  # Replaying a seeded source checks rerolling without assuming random rolls differ.
+  def test_rolls_use_the_random_source_and_values_stay_stable
+    dice = Exercises::AboutDiceProject::DiceSet.new(random: Random.new(12))
+    oracle = Random.new(12)
+    2.times do
+      expected = Array.new(5) { oracle.rand(1..6) }
+      dice.roll(5)
+      first_read = dice.values.dup
+
+      assert_equal expected, first_read
+      assert_equal first_read, dice.values
+    end
+  end
+end

data/test/exercises/about_exceptions_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Assignments before later reassignment or return are part of the experiment.
+# Keep the original koan check name.
+# This example deliberately raises an exception instance rather than a class and message pair.
+# The examples demonstrate raise and fail as synonyms.
+# rubocop:disable Lint/UselessAssignment, Naming/MethodName, Style/RaiseArgs, Style/SignalException
+
+# 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 AboutExceptionsTest < Minitest::Test
+  class MySpecialError < RuntimeError
+  end
+
+  # Checks exceptions inherit from Exception.
+  def test_exceptions_inherit_from_Exception
+    assert_equal Exercises::AboutExceptions.koans.fetch(:exceptions_inherit_from_Exception_one),
+                 MySpecialError.ancestors[1]
+    assert_equal Exercises::AboutExceptions.koans.fetch(:exceptions_inherit_from_Exception_two),
+                 MySpecialError.ancestors[2]
+    assert_equal Exercises::AboutExceptions.koans.fetch(:exceptions_inherit_from_Exception_three),
+                 MySpecialError.ancestors[3]
+    assert_equal Exercises::AboutExceptions.koans.fetch(:exceptions_inherit_from_Exception_four),
+                 MySpecialError.ancestors[4]
+  end
+
+  # Checks rescue clause.
+  def test_rescue_clause
+    result = nil
+    begin
+      fail 'Oops'
+    rescue StandardError => e
+      result = :exception_handled
+    end
+
+    assert_equal Exercises::AboutExceptions.koans.fetch(:rescue_clause_one), result
+
+    assert_equal Exercises::AboutExceptions.koans.fetch(:rescue_clause_two), e.is_a?(StandardError)
+    assert_equal Exercises::AboutExceptions.koans.fetch(:rescue_clause_three), e.is_a?(RuntimeError)
+
+    assert_includes RuntimeError.ancestors, StandardError,
+                    'RuntimeError is a subclass of StandardError'
+
+    assert_equal Exercises::AboutExceptions.koans.fetch(:rescue_clause_four), e.message
+  end
+
+  # Checks raising a particular error.
+  def test_raising_a_particular_error
+    result = nil
+    begin
+      # 'raise' and 'fail' are synonyms
+      raise MySpecialError, 'My Message'
+    rescue MySpecialError => e
+      result = :exception_handled
+    end
+
+    assert_equal Exercises::AboutExceptions.koans.fetch(:raising_a_particular_error_one), result
+    assert_equal Exercises::AboutExceptions.koans.fetch(:raising_a_particular_error_two), e.message
+  end
+
+  # Checks ensure clause.
+  def test_ensure_clause
+    result = nil
+    begin
+      fail 'Oops'
+    rescue StandardError
+      # no code here
+    ensure
+      result = :always_run
+    end
+
+    assert_equal Exercises::AboutExceptions.koans.fetch(:ensure_clause_one), result
+  end
+
+  # Sometimes, we must know about the unknown
+  # Checks asserting an error is raised.
+  def test_asserting_an_error_is_raised
+    # A do-end is a block, a topic to explore more later
+    assert_predicted_error(:asserting_an_error_is_raised_one, ::AboutExceptionsTest::MySpecialError) do
+      raise MySpecialError.new('New instances can be raised directly.')
+    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::AboutExceptions.koans.fetch(key), error.class
+    error
+  end
+end
+
+# rubocop:enable Lint/UselessAssignment, Naming/MethodName, Style/RaiseArgs, Style/SignalException