rkoans 0.0.1 → 0.1.0

data/test/exercises/about_message_passing_test.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+# The original descriptive check identifiers and example strings remain intact.
+# An empty class demonstrates construction without custom methods.
+# The example deliberately contrasts received arguments with values actually used.
+# The direct method call is compared with send and __send__ in this chapter.
+# The block name is observable through parameter metadata or the explicit forwarding example.
+# The exercise makes positional, keyword, and block forwarding visible.
+# This catcher deliberately demonstrates misleading introspection.
+# The dynamic message example constructs a method name from separate strings.
+# Explicit forwarding makes the missing-method and visibility arguments visible.
+# rubocop:disable Layout/LineLength, Lint/EmptyClass, Lint/UnusedMethodArgument, Minitest/AssertPredicate, Naming/BlockForwarding, Style/ArgumentsForwarding, Style/MissingRespondToMissing, Style/StringConcatenation, Style/SuperArguments
+
+# 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 AboutMessagePassingTest < Minitest::Test
+  class MessageCatcher
+    # Demonstrates caught?.
+    def caught?
+      true
+    end
+  end
+
+  # Checks methods can be called directly.
+  def test_methods_can_be_called_directly
+    mc = MessageCatcher.new
+
+    assert mc.caught?
+  end
+
+  # Checks methods can be invoked by sending the message.
+  def test_methods_can_be_invoked_by_sending_the_message
+    mc = MessageCatcher.new
+
+    assert mc.send(:caught?)
+  end
+
+  # Checks methods can be invoked more dynamically.
+  def test_methods_can_be_invoked_more_dynamically
+    mc = MessageCatcher.new
+
+    assert mc.send('caught?')
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:methods_can_be_invoked_more_dynamically_one), mc.send('caught' + '?') # What do you need to add to the first string?
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:methods_can_be_invoked_more_dynamically_two), mc.send('CAUGHT?'.downcase) # What would you need to do to the string?
+  end
+
+  # Checks send with underscores will also send messages.
+  def test_send_with_underscores_will_also_send_messages
+    mc = MessageCatcher.new
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:send_with_underscores_will_also_send_messages_one),
+                 mc.__send__(:caught?)
+
+    # THINK ABOUT IT:
+    #
+    # Why does Ruby provide both send and __send__ ?
+  end
+
+  # Checks classes can be asked if they know how to respond.
+  def test_classes_can_be_asked_if_they_know_how_to_respond
+    mc = MessageCatcher.new
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:classes_can_be_asked_if_they_know_how_to_respond_one),
+                 mc.respond_to?(:caught?)
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:classes_can_be_asked_if_they_know_how_to_respond_two),
+                 mc.respond_to?(:does_not_exist)
+  end
+
+  # ------------------------------------------------------------------
+
+  class MessageCatcher
+    # Demonstrates add a payload.
+    def add_a_payload(*args)
+      args
+    end
+  end
+
+  # Checks sending a message with arguments.
+  def test_sending_a_message_with_arguments
+    mc = MessageCatcher.new
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:sending_a_message_with_arguments_one), mc.add_a_payload
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:sending_a_message_with_arguments_two),
+                 mc.send(:add_a_payload)
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:sending_a_message_with_arguments_three),
+                 mc.add_a_payload(3, 4, nil, 6)
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:sending_a_message_with_arguments_four),
+                 mc.send(:add_a_payload, 3, 4, nil, 6)
+  end
+
+  # Message dispatch:
+  #
+  # Both obj.msg and obj.send(:msg) sends the message named :msg to
+  # the object. We use "send" when the name of the message can vary
+  # dynamically (e.g. calculated at run time), but by far the most
+  # common way of sending a message is just to say: obj.msg.
+
+  # ------------------------------------------------------------------
+
+  class TypicalObject
+  end
+
+  # Checks sending undefined messages to a typical object results in errors.
+  def test_sending_undefined_messages_to_a_typical_object_results_in_errors
+    typical = TypicalObject.new
+
+    exception = assert_predicted_error(:sending_undefined_messages_to_a_typical_object_results_in_errors_one,
+                                       ::NoMethodError) do
+      typical.foobar
+    end
+    assert_match(/foobar/, exception.message)
+  end
+
+  # Checks calling method missing causes the no method error.
+  def test_calling_method_missing_causes_the_no_method_error
+    typical = TypicalObject.new
+
+    exception = assert_predicted_error(:calling_method_missing_causes_the_no_method_error_one, ::NoMethodError) do
+      typical.__send__(:method_missing, :foobar)
+    end
+    assert_match(/foobar/, exception.message)
+
+    # THINK ABOUT IT:
+    #
+    # If the method :method_missing causes the NoMethodError, then
+    # what would happen if we redefine method_missing?
+    #
+  end
+
+  # ------------------------------------------------------------------
+
+  class AllMessageCatcher
+    # Demonstrates method missing.
+    def method_missing(method_name, *args, &block)
+      "Someone called #{method_name} with <#{args.join(', ')}>"
+    end
+  end
+
+  # Checks all messages are caught.
+  def test_all_messages_are_caught
+    catcher = AllMessageCatcher.new
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:all_messages_are_caught_one), catcher.foobar
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:all_messages_are_caught_two), catcher.foobaz(1)
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:all_messages_are_caught_three),
+                 catcher.sum(1, 2, 3, 4, 5, 6)
+  end
+
+  # Checks catching messages makes respond to lie.
+  def test_catching_messages_makes_respond_to_lie
+    catcher = AllMessageCatcher.new
+
+    catcher.any_method
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:catching_messages_makes_respond_to_lie_one),
+                 catcher.respond_to?(:any_method)
+  end
+
+  # ------------------------------------------------------------------
+
+  class WellBehavedFooCatcher
+    # Demonstrates method missing.
+    def method_missing(method_name, *args, &block)
+      if method_name.to_s[0, 3] == 'foo'
+        'Foo to you too'
+      else
+        super(method_name, *args, &block)
+      end
+    end
+  end
+
+  # Checks foo method are caught.
+  def test_foo_method_are_caught
+    catcher = WellBehavedFooCatcher.new
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:foo_method_are_caught_one), catcher.foo_bar
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:foo_method_are_caught_two), catcher.foo_baz
+  end
+
+  # Checks non foo messages are treated normally.
+  def test_non_foo_messages_are_treated_normally
+    catcher = WellBehavedFooCatcher.new
+
+    assert_predicted_error(:non_foo_messages_are_treated_normally_one, ::NoMethodError) do
+      catcher.normal_undefined_method
+    end
+  end
+
+  # ------------------------------------------------------------------
+
+  # (note: just reopening class from above)
+  class WellBehavedFooCatcher
+    private
+
+    # Demonstrates respond to missing?.
+    def respond_to_missing?(method_name, include_private = false)
+      if method_name.to_s[0, 3] == 'foo'
+        true
+      else
+        super(method_name, include_private)
+      end
+    end
+  end
+
+  # Checks explicitly implementing respond to lets objects tell the truth.
+  def test_explicitly_implementing_respond_to_lets_objects_tell_the_truth
+    catcher = WellBehavedFooCatcher.new
+
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:explicitly_implementing_respond_to_lets_objects_tell_the_truth_one),
+                 catcher.respond_to?(:foo_bar)
+    assert_equal Exercises::AboutMessagePassing.koans.fetch(:explicitly_implementing_respond_to_lets_objects_tell_the_truth_two),
+                 catcher.respond_to?(:something_else)
+  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::AboutMessagePassing.koans.fetch(key), error.class
+    error
+  end
+end
+
+# rubocop:enable Layout/LineLength, Lint/EmptyClass, Lint/UnusedMethodArgument, Minitest/AssertPredicate, Naming/BlockForwarding, Style/ArgumentsForwarding, Style/MissingRespondToMissing, Style/StringConcatenation, Style/SuperArguments

data/test/exercises/about_methods_test.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# The unreachable expression demonstrates the effect of explicit return.
+# Non-returned expressions demonstrate method return behavior.
+# Keep the related original chapter examples together.
+# Short parameter names match the small arithmetic or assignment examples.
+# The fixed literal expression is an isolated binding or syntax experiment.
+# The explicit receiver is part of the method-call experiment.
+# rubocop:disable Lint/UnreachableCode, Lint/Void, Metrics/ClassLength, Naming/MethodParameterName, Style/EvalWithLocation, Style/RedundantSelf
+
+# 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
+# Demonstrates my global method.
+def my_global_method(a, b)
+  a + b
+end
+
+class AboutMethodsTest < Minitest::Test
+  # Checks calling global methods.
+  def test_calling_global_methods
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_global_methods_one), my_global_method(2, 3)
+  end
+
+  # Checks calling global methods without parentheses.
+  def test_calling_global_methods_without_parentheses
+    result = my_global_method 2, 3
+
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_global_methods_without_parentheses_one), result
+  end
+
+  # Parentheses make the inner call's argument list explicit.
+  # Checks sometimes missing parentheses are ambiguous.
+  def test_sometimes_missing_parentheses_are_ambiguous
+    assert_equal Exercises::AboutMethods.koans.fetch(:sometimes_missing_parentheses_are_ambiguous_one),
+                 eval('my_global_method(2, 3)')
+  end
+
+  # NOTE: wrong number of arguments is not a SYNTAX error, but a
+  # runtime error.
+  # Checks calling global methods with wrong number of arguments.
+  def test_calling_global_methods_with_wrong_number_of_arguments
+    exception = assert_predicted_error(:calling_global_methods_with_wrong_number_of_arguments_one, ::ArgumentError) do
+      my_global_method
+    end
+    assert_predicted_message(:calling_global_methods_with_wrong_number_of_arguments_two, exception.message)
+
+    exception = assert_predicted_error(:calling_global_methods_with_wrong_number_of_arguments_three, ::ArgumentError) do
+      my_global_method(1, 2, 3)
+    end
+    assert_predicted_message(:calling_global_methods_with_wrong_number_of_arguments_four, exception.message)
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates method with defaults.
+  def method_with_defaults(a, b = :default_value)
+    [a, b]
+  end
+
+  # Checks calling with default values.
+  def test_calling_with_default_values
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_with_default_values_one), method_with_defaults(1)
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_with_default_values_two), method_with_defaults(1, 2)
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates method with var args.
+  def method_with_var_args(*args)
+    args
+  end
+
+  # Checks calling with variable arguments.
+  def test_calling_with_variable_arguments
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_with_variable_arguments_one), method_with_var_args.class
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_with_variable_arguments_two), method_with_var_args
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_with_variable_arguments_three),
+                 method_with_var_args(:one)
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_with_variable_arguments_four),
+                 method_with_var_args(:one, :two)
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates method with explicit return.
+  def method_with_explicit_return
+    :a_non_return_value
+    return :return_value
+    :another_non_return_value
+  end
+
+  # Checks method with explicit return.
+  def test_method_with_explicit_return
+    assert_equal Exercises::AboutMethods.koans.fetch(:method_with_explicit_return_one), method_with_explicit_return
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates method without explicit return.
+  def method_without_explicit_return
+    :a_non_return_value
+    :return_value
+  end
+
+  # Checks method without explicit return.
+  def test_method_without_explicit_return
+    assert_equal Exercises::AboutMethods.koans.fetch(:method_without_explicit_return_one),
+                 method_without_explicit_return
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates my method in the same class.
+  def my_method_in_the_same_class(a, b)
+    a * b
+  end
+
+  # Checks calling methods in same class.
+  def test_calling_methods_in_same_class
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_methods_in_same_class_one),
+                 my_method_in_the_same_class(3, 4)
+  end
+
+  # Checks calling methods in same class with explicit receiver.
+  def test_calling_methods_in_same_class_with_explicit_receiver
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_methods_in_same_class_with_explicit_receiver_one),
+                 self.my_method_in_the_same_class(3, 4)
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates my private method.
+  def my_private_method
+    'a secret'
+  end
+  private :my_private_method
+
+  # Checks calling private methods without receiver.
+  def test_calling_private_methods_without_receiver
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_private_methods_without_receiver_one), my_private_method
+  end
+
+  # Modern Ruby permits self as the receiver of a private method.
+  # Checks calling private methods with an explicit receiver.
+  def test_calling_private_methods_with_an_explicit_receiver
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_private_methods_with_an_explicit_receiver_one),
+                 self.my_private_method
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog
+    # Demonstrates name.
+    def name
+      'Fido'
+    end
+
+    private
+
+    # Demonstrates tail.
+    def tail
+      'tail'
+    end
+  end
+
+  # Checks calling methods in other objects require explicit receiver.
+  def test_calling_methods_in_other_objects_require_explicit_receiver
+    rover = Dog.new
+
+    assert_equal Exercises::AboutMethods.koans.fetch(:calling_methods_in_other_objects_require_explicit_receiver_one),
+                 rover.name
+  end
+
+  # Checks calling private methods in other objects.
+  def test_calling_private_methods_in_other_objects
+    rover = Dog.new
+    assert_predicted_error(:calling_private_methods_in_other_objects_one, ::NoMethodError) do
+      rover.tail
+    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::AboutMethods.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::AboutMethods.koans.fetch(key)
+
+    assert_kind_of String, fragment
+    refute_empty fragment
+    assert_includes message, fragment
+  end
+end
+
+# rubocop:enable Lint/UnreachableCode, Lint/Void, Metrics/ClassLength, Naming/MethodParameterName, Style/EvalWithLocation, Style/RedundantSelf

data/test/exercises/about_modules_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Explicit setters are compared with generated accessors in this chapter.
+# rubocop:disable Naming/AccessorMethodName
+
+# 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 AboutModulesTest < Minitest::Test
+  module Nameable
+    # Demonstrates set name.
+    def set_name(new_name)
+      @name = new_name
+    end
+
+    # Demonstrates here.
+    def here
+      :in_module
+    end
+  end
+
+  # Checks cant instantiate modules.
+  def test_cant_instantiate_modules
+    assert_predicted_error(:cant_instantiate_modules_one, ::NoMethodError) do
+      Nameable.new
+    end
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog
+    include Nameable
+
+    attr_reader :name
+
+    # Demonstrates initialize.
+    def initialize
+      @name = 'Fido'
+    end
+
+    # Demonstrates bark.
+    def bark
+      'WOOF'
+    end
+
+    # Demonstrates here.
+    def here
+      :in_object
+    end
+  end
+
+  # Checks normal methods are available in the object.
+  def test_normal_methods_are_available_in_the_object
+    fido = Dog.new
+
+    assert_equal Exercises::AboutModules.koans.fetch(:normal_methods_are_available_in_the_object_one), fido.bark
+  end
+
+  # Checks module methods are also available in the object.
+  def test_module_methods_are_also_available_in_the_object
+    fido = Dog.new
+
+    fido.set_name('Rover')
+  end
+
+  # Checks module methods can affect instance variables in the object.
+  def test_module_methods_can_affect_instance_variables_in_the_object
+    fido = Dog.new
+
+    assert_equal Exercises::AboutModules.koans.fetch(:module_methods_can_affect_instance_variables_in_the_object_one),
+                 fido.name
+    fido.set_name('Rover')
+
+    assert_equal Exercises::AboutModules.koans.fetch(:module_methods_can_affect_instance_variables_in_the_object_two),
+                 fido.name
+  end
+
+  # Checks classes can override module methods.
+  def test_classes_can_override_module_methods
+    fido = Dog.new
+
+    assert_equal Exercises::AboutModules.koans.fetch(:classes_can_override_module_methods_one), fido.here
+  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::AboutModules.koans.fetch(key), error.class
+    error
+  end
+end
+
+# rubocop:enable Naming/AccessorMethodName

data/test/exercises/about_nil_test.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.
+
+require ARGV.shift
+
+# Observes nil as an object with methods and ordinary missing-method errors.
+class AboutNilTest < Minitest::Test
+  # Nil is an object rather than an absent receiver.
+  def test_nil_is_an_object
+    assert_equal Exercises::AboutNil.koans[:nil_object], nil.is_a?(Object)
+  end
+
+  # Missing methods raise an error with an inspectable class and message.
+  def test_you_dont_get_null_pointer_errors_when_calling_methods_on_nil
+    error = assert_raises(NoMethodError) { nil.some_method_nil_doesnt_know_about }
+    answers = Exercises::AboutNil.koans
+
+    assert_equal answers[:missing_method_error], error.class
+    assert_kind_of String, answers[:message_fragment]
+    refute_empty answers[:message_fragment]
+    assert_includes error.message, answers[:message_fragment]
+  end
+
+  # Nil supports a predicate, string conversion, and inspection.
+  def test_nil_has_a_few_methods_defined_on_it
+    answers = Exercises::AboutNil.koans
+
+    assert_equal answers[:nil_predicate], nil.nil?
+    assert_equal answers[:string_value], nil.to_s
+    assert_equal answers[:inspected_value], nil.inspect
+  end
+end

data/test/exercises/about_objects_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
+
+# Observes object conversion, inspection, and identity.
+class AboutObjectsTest < Minitest::Test
+  # These ordinary values, including nil and a class, are objects.
+  def test_everything_is_an_object
+    answers = Exercises::AboutObjects.koans
+
+    assert_equal answers[:integer_object], 1.is_a?(Object)
+    assert_equal answers[:float_object], 1.5.is_a?(Object)
+    assert_equal answers[:string_object], 'string'.is_a?(Object)
+    assert_equal answers[:nil_object], nil.is_a?(Object)
+    assert_equal answers[:class_object], Object.is_a?(Object)
+  end
+
+  # String conversion can produce an empty string.
+  def test_objects_can_be_converted_to_strings
+    answers = Exercises::AboutObjects.koans
+
+    assert_equal answers[:integer_string], 123.to_s
+    assert_equal answers[:nil_string], nil.to_s
+  end
+
+  # Inspection provides a diagnostic representation.
+  def test_objects_can_be_inspected
+    answers = Exercises::AboutObjects.koans
+
+    assert_equal answers[:integer_inspect], 123.inspect
+    assert_equal answers[:nil_inspect], nil.inspect
+  end
+
+  # An object identifier is an integer.
+  def test_every_object_has_an_id
+    obj = Object.new
+    answers = Exercises::AboutObjects.koans
+
+    assert_equal answers[:id_type], obj.object_id.class
+  end
+
+  # Two live objects have distinct identifiers.
+  def test_every_object_has_different_id
+    obj = Object.new
+    another_obj = Object.new
+    answers = Exercises::AboutObjects.koans
+
+    assert_equal answers[:distinct_ids], obj.object_id != another_obj.object_id # rubocop:disable Lint/IdentityComparison
+  end
+
+  # Observe the MRI representation of these small integers.
+  def test_small_integers_have_fixed_ids
+    answers = Exercises::AboutObjects.koans
+
+    assert_equal answers[:zero_id], 0.object_id
+    assert_equal answers[:one_id], 1.object_id
+    assert_equal answers[:two_id], 2.object_id
+    assert_equal answers[:hundred_id], 100.object_id
+  end
+
+  # Cloning a plain object creates a different object with a different ID.
+  def test_clone_creates_a_different_object
+    obj = Object.new
+    copy = obj.clone
+    answers = Exercises::AboutObjects.koans
+
+    assert_equal answers[:clone_unequal], obj != copy
+    assert_equal answers[:clone_distinct_id], obj.object_id != copy.object_id # rubocop:disable Lint/IdentityComparison
+  end
+end