rkoans 0.0.1 → 0.1.0

data/test/exercises/about_array_assignment_test.rb

@@ -0,0 +1,87 @@
+# 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 assignment syntax rather than rewriting the expressions being taught.
+# rubocop:disable Style/WordArray, Style/ParallelAssignment
+
+require ARGV.shift
+
+# Observes how assignment distributes, collects, and preserves array values.
+class AboutArrayAssignmentTest < Minitest::Test
+  # Assigning to one variable keeps the entire array.
+  def test_non_parallel_assignment
+    names = ['John', 'Smith']
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:names], names
+  end
+
+  # Parallel assignment distributes values in order.
+  def test_parallel_assignments
+    first_name, last_name = ['John', 'Smith']
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:first_name], first_name
+    assert_equal answers[:last_name], last_name
+  end
+
+  # Extra values are discarded without a splat.
+  def test_parallel_assignments_with_extra_values
+    first_name, last_name = ['John', 'Smith', 'III']
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:extra_first], first_name
+    assert_equal answers[:extra_last], last_name
+  end
+
+  # A splat collects the remaining values in an array.
+  def test_parallel_assignments_with_splat_operator
+    first_name, *last_name = ['John', 'Smith', 'III']
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:splat_first], first_name
+    assert_equal answers[:splat_last], last_name
+  end
+
+  # Missing values become nil.
+  def test_parallel_assignments_with_too_few_values
+    first_name, last_name = ['Cher']
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:short_first], first_name
+    assert_equal answers[:short_last], last_name
+  end
+
+  # An inner array remains a single assigned value.
+  def test_parallel_assignments_with_subarrays
+    first_name, last_name = [['Willie', 'Rae'], 'Johnson']
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:nested_first], first_name
+    assert_equal answers[:nested_last], last_name
+  end
+
+  # A trailing comma requests parallel assignment with one variable.
+  def test_parallel_assignment_with_one_variable
+    first_name, = ['John', 'Smith']
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:single_first], first_name
+  end
+
+  # Right-hand values are evaluated before the assignments.
+  def test_swapping_with_parallel_assignment
+    first_name = 'Roy'
+    last_name = 'Rob'
+    first_name, last_name = last_name, first_name
+    answers = Exercises::AboutArrayAssignment.koans
+
+    assert_equal answers[:swapped_first], first_name
+    assert_equal answers[:swapped_last], last_name
+  end
+end
+
+# rubocop:enable Style/WordArray, Style/ParallelAssignment

data/test/exercises/about_arrays_test.rb

@@ -0,0 +1,119 @@
+# 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.
+
+require ARGV.shift
+
+# Observes array values before and after indexing, slicing, and mutations.
+class AboutArraysTest < Minitest::Test
+  # A new array has a type and an initial size.
+  def test_creating_arrays
+    empty_array = Array.new # rubocop:disable Style/EmptyLiteral
+    answers = Exercises::AboutArrays.koans
+
+    assert_equal answers[:empty_type], empty_array.class
+    assert_equal answers[:empty_size], empty_array.size
+  end
+
+  # Indexed assignment and appending build an array incrementally.
+  def test_array_literals
+    array = Array.new # rubocop:disable Style/EmptyLiteral
+
+    assert_equal [], array
+
+    array[0] = 1
+
+    assert_equal [1], array
+
+    answers = Exercises::AboutArrays.koans
+    array[1] = 2
+
+    assert_equal [1, answers[:second_literal]], array
+
+    array << 333
+
+    assert_equal answers[:after_append], array
+  end
+
+  # Positive indexes count from the start; negative indexes count from the end.
+  def test_accessing_array_elements
+    array = [:peanut, :butter, :and, :jelly]
+    answers = Exercises::AboutArrays.koans
+
+    assert_equal answers[:first_index], array[0]
+    assert_equal answers[:first_method], array.first
+    assert_equal answers[:last_index], array[3]
+    assert_equal answers[:last_method], array.last
+    assert_equal answers[:negative_last], array[-1]
+    assert_equal answers[:negative_third], array[-3]
+  end
+
+  # Slices distinguish a starting index at the end from one beyond the end.
+  def test_slicing_arrays
+    array = [:peanut, :butter, :and, :jelly]
+    answers = Exercises::AboutArrays.koans
+
+    assert_equal answers[:slice_one], array[0, 1]
+    assert_equal answers[:slice_two], array[0, 2]
+    assert_equal answers[:slice_tail], array[2, 2]
+    assert_equal answers[:slice_long_tail], array[2, 20]
+    assert_equal answers[:slice_at_end_zero], array[4, 0]
+    assert_equal answers[:slice_at_end_long], array[4, 100]
+    assert_equal answers[:slice_beyond_end], array[5, 0]
+  end
+
+  # A range differs from an array and can include or exclude its endpoint.
+  def test_arrays_and_ranges
+    answers = Exercises::AboutArrays.koans
+
+    assert_equal answers[:range_type], (1..5).class
+    refute_equal [1, 2, 3, 4, 5], (1..5)
+    assert_equal answers[:inclusive_range], (1..5).to_a
+    assert_equal answers[:exclusive_range], (1...5).to_a
+  end
+
+  # Ranges select slices and can end at a negative index.
+  def test_slicing_with_ranges
+    array = [:peanut, :butter, :and, :jelly]
+    answers = Exercises::AboutArrays.koans
+
+    assert_equal answers[:inclusive_slice], array[0..2]
+    assert_equal answers[:exclusive_slice], array[0...2]
+    assert_equal answers[:negative_range_slice], array[2..-1] # rubocop:disable Style/SlicingWithRange
+  end
+
+  # Push and pop change the end of an array; pop returns the removed element.
+  def test_pushing_and_popping_arrays
+    array = [1, 2]
+    array.push(:last)
+    answers = Exercises::AboutArrays.koans
+
+    assert_equal answers[:after_push], array
+
+    popped_value = array.pop
+
+    assert_equal answers[:popped_value], popped_value
+    assert_equal answers[:after_pop], array
+  end
+
+  # Unshift and shift change the start; shift returns the removed element.
+  def test_shifting_arrays
+    array = [1, 2]
+    array.unshift(:first)
+    answers = Exercises::AboutArrays.koans
+
+    assert_equal answers[:after_unshift], array
+
+    shifted_value = array.shift
+
+    assert_equal answers[:shifted_value], shifted_value
+    assert_equal answers[:after_shift], array
+  end
+end
+
+# rubocop:enable Style/SymbolArray

data/test/exercises/about_asserts_test.rb

@@ -0,0 +1,41 @@
+# 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
+
+# Introduces assertion truth, failure messages, equality, and expected values.
+class AboutAssertsTest < Minitest::Test
+  # We shall contemplate truth by testing reality, via asserts.
+  def test_assert_truth
+    assert Exercises::AboutAsserts.koans[:truth]
+  end
+
+  # Enlightenment may be more easily achieved with appropriate messages.
+  def test_assert_with_message
+    assert Exercises::AboutAsserts.koans[:with_message], 'This should be true -- Please fix this'
+  end
+
+  # Compare expectations with reality using bare assert before the better diagnostic below.
+  def test_assert_equality
+    expected_value = Exercises::AboutAsserts.koans[:expected_value]
+    actual_value = 1 + 1
+
+    assert expected_value == actual_value # rubocop:disable Minitest/AssertEqual, Minitest/AssertOperator
+  end
+
+  # Some ways of asserting equality are better than others.
+  def test_a_better_way_of_asserting_equality
+    expected_value = Exercises::AboutAsserts.koans[:better_expected_value]
+    actual_value = 1 + 1
+
+    assert_equal expected_value, actual_value
+  end
+
+  # Sometimes we will ask you to fill in the values.
+  def test_fill_in_values
+    assert_equal Exercises::AboutAsserts.koans[:filled_value], 1 + 1
+  end
+end

data/test/exercises/about_blocks_test.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# The original descriptive check identifiers and example strings remain intact.
+# The examples contrast block forms and their behavior.
+# The example preserves the callable syntax being taught.
+# Explicit callable arguments demonstrate block and proc behavior.
+# rubocop:disable Layout/LineLength, Style/BlockDelimiters, Style/Lambda, Style/SymbolProc
+
+# 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 AboutBlocksTest < Minitest::Test
+  # Demonstrates method with block.
+  def method_with_block
+    yield
+  end
+
+  # Checks methods can take blocks.
+  def test_methods_can_take_blocks
+    yielded_result = method_with_block { 1 + 2 }
+
+    assert_equal Exercises::AboutBlocks.koans.fetch(:methods_can_take_blocks_one), yielded_result
+  end
+
+  # Checks blocks can be defined with do end too.
+  def test_blocks_can_be_defined_with_do_end_too
+    yielded_result = method_with_block do
+      1 + 2
+    end
+
+    assert_equal Exercises::AboutBlocks.koans.fetch(:blocks_can_be_defined_with_do_end_too_one), yielded_result
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates method with block arguments.
+  def method_with_block_arguments
+    yield('Jim')
+  end
+
+  # Checks blocks can take arguments.
+  def test_blocks_can_take_arguments
+    method_with_block_arguments do |argument|
+      assert_equal Exercises::AboutBlocks.koans.fetch(:blocks_can_take_arguments_one), argument
+    end
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates many yields.
+  def many_yields
+    yield(:peanut)
+    yield(:butter)
+    yield(:and)
+    yield(:jelly)
+  end
+
+  # Checks methods can call yield many times.
+  def test_methods_can_call_yield_many_times
+    result = []
+    many_yields { |item| result << item }
+
+    assert_equal Exercises::AboutBlocks.koans.fetch(:methods_can_call_yield_many_times_one), result
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates yield tester.
+  def yield_tester
+    if block_given?
+      yield
+    else
+      :no_block
+    end
+  end
+
+  # Checks methods can see if they have been called with a block.
+  def test_methods_can_see_if_they_have_been_called_with_a_block
+    assert_equal(Exercises::AboutBlocks.koans.fetch(:methods_can_see_if_they_have_been_called_with_a_block_one), yield_tester {
+      :with_block
+    })
+    assert_equal Exercises::AboutBlocks.koans.fetch(:methods_can_see_if_they_have_been_called_with_a_block_two),
+                 yield_tester
+  end
+
+  # ------------------------------------------------------------------
+
+  # Checks block can affect variables in the code where they are created.
+  def test_block_can_affect_variables_in_the_code_where_they_are_created
+    value = :initial_value
+    method_with_block { value = :modified_in_a_block }
+
+    assert_equal Exercises::AboutBlocks.koans.fetch(:block_can_affect_variables_in_the_code_where_they_are_created_one),
+                 value
+  end
+
+  # Checks blocks can be assigned to variables and called explicitly.
+  def test_blocks_can_be_assigned_to_variables_and_called_explicitly
+    add_one = lambda { |n| n + 1 }
+
+    assert_equal Exercises::AboutBlocks.koans.fetch(:blocks_can_be_assigned_to_variables_and_called_explicitly_one),
+                 add_one.call(10)
+
+    # Alternative calling syntax
+    assert_equal Exercises::AboutBlocks.koans.fetch(:blocks_can_be_assigned_to_variables_and_called_explicitly_two),
+                 add_one[10]
+  end
+
+  # Checks stand alone blocks can be passed to methods expecting blocks.
+  def test_stand_alone_blocks_can_be_passed_to_methods_expecting_blocks
+    make_upper = lambda { |n| n.upcase }
+    result = method_with_block_arguments(&make_upper)
+
+    assert_equal Exercises::AboutBlocks.koans.fetch(:stand_alone_blocks_can_be_passed_to_methods_expecting_blocks_one),
+                 result
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates method with explicit block.
+  def method_with_explicit_block(&block)
+    block.call(10)
+  end
+
+  # Checks methods can take an explicit block argument.
+  def test_methods_can_take_an_explicit_block_argument
+    assert_equal(Exercises::AboutBlocks.koans.fetch(:methods_can_take_an_explicit_block_argument_one), method_with_explicit_block { |n|
+      n * 2
+    })
+
+    add_one = lambda { |n| n + 1 }
+
+    assert_equal Exercises::AboutBlocks.koans.fetch(:methods_can_take_an_explicit_block_argument_two),
+                 method_with_explicit_block(&add_one)
+  end
+end
+
+# rubocop:enable Layout/LineLength, Style/BlockDelimiters, Style/Lambda, Style/SymbolProc

data/test/exercises/about_class_methods_test.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+# An empty class demonstrates construction without custom methods.
+# These original names demonstrate constants and class objects.
+# The lesson contrasts explicit class receivers with self and singleton-class syntax.
+# Explicit getter definitions are compared with attr_reader and attr_accessor.
+# rubocop:disable Lint/EmptyClass, Naming/ConstantName, Style/ClassMethods, 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 AboutClassMethodsTest < Minitest::Test
+  class Dog
+  end
+
+  # Checks objects are objects.
+  def test_objects_are_objects
+    fido = Dog.new
+
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:objects_are_objects_one), fido.is_a?(Object)
+  end
+
+  # Checks classes are classes.
+  def test_classes_are_classes
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:classes_are_classes_one), Dog.is_a?(Class)
+  end
+
+  # Checks classes are objects too.
+  def test_classes_are_objects_too
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:classes_are_objects_too_one), Dog.is_a?(Object)
+  end
+
+  # Checks objects have methods.
+  def test_objects_have_methods
+    fido = Dog.new
+
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:objects_have_methods_one), fido.methods.any?
+  end
+
+  # Checks classes have methods.
+  def test_classes_have_methods
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:classes_have_methods_one), Dog.methods.any?
+  end
+
+  # Checks you can define methods on individual objects.
+  def test_you_can_define_methods_on_individual_objects
+    fido = Dog.new
+    # Demonstrates fido.wag.
+    def fido.wag
+      :fidos_wag
+    end
+
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:you_can_define_methods_on_individual_objects_one), fido.wag
+  end
+
+  # Checks other objects are not affected by these singleton methods.
+  def test_other_objects_are_not_affected_by_these_singleton_methods
+    fido = Dog.new
+    rover = Dog.new
+    # Demonstrates fido.wag.
+    def fido.wag
+      :fidos_wag
+    end
+
+    assert_predicted_error(:other_objects_are_not_affected_by_these_singleton_methods_one, ::NoMethodError) do
+      rover.wag
+    end
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog2
+    # Demonstrates wag.
+    def wag
+      :instance_level_wag
+    end
+  end
+
+  # Demonstrates Dog2.wag.
+  def Dog2.wag
+    :class_level_wag
+  end
+
+  # Checks since classes are objects you can define singleton methods on them too.
+  def test_since_classes_are_objects_you_can_define_singleton_methods_on_them_too
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:since_classes_are_objects_you_can_define_singleton_methods_on_them_too_one),
+                 Dog2.wag
+  end
+
+  # Checks class methods are independent of instance methods.
+  def test_class_methods_are_independent_of_instance_methods
+    fido = Dog2.new
+
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:class_methods_are_independent_of_instance_methods_one),
+                 fido.wag
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:class_methods_are_independent_of_instance_methods_two),
+                 Dog2.wag
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog
+    attr_accessor :name
+  end
+
+  # Demonstrates Dog.name.
+  def Dog.name
+    @name
+  end
+
+  # Checks classes and instances do not share instance variables.
+  def test_classes_and_instances_do_not_share_instance_variables
+    fido = Dog.new
+    fido.name = 'Fido'
+
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:classes_and_instances_do_not_share_instance_variables_one),
+                 fido.name
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:classes_and_instances_do_not_share_instance_variables_two),
+                 Dog.name
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog
+    # Demonstrates Dog.a class method.
+    def Dog.a_class_method
+      :dogs_class_method
+    end
+  end
+
+  # Checks you can define class methods inside the class.
+  def test_you_can_define_class_methods_inside_the_class
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:you_can_define_class_methods_inside_the_class_one),
+                 Dog.a_class_method
+  end
+
+  # ------------------------------------------------------------------
+
+  LastExpressionInClassStatement = class Dog
+                                     21
+                                   end
+
+  # Checks class statements return the value of their last expression.
+  def test_class_statements_return_the_value_of_their_last_expression
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:class_statements_return_the_value_of_their_last_expression_one),
+                 LastExpressionInClassStatement
+  end
+
+  # ------------------------------------------------------------------
+
+  SelfInsideOfClassStatement = class Dog
+                                 self
+                               end
+
+  # Checks self while inside class is class object not instance.
+  def test_self_while_inside_class_is_class_object_not_instance
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:self_while_inside_class_is_class_object_not_instance_one),
+                 (Dog == SelfInsideOfClassStatement)
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog
+    # Demonstrates self.class method2.
+    def self.class_method2
+      :another_way_to_write_class_methods
+    end
+  end
+
+  # Checks you can use self instead of an explicit reference to dog.
+  def test_you_can_use_self_instead_of_an_explicit_reference_to_dog
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:you_can_use_self_instead_of_an_explicit_reference_to_dog_one),
+                 Dog.class_method2
+  end
+
+  # ------------------------------------------------------------------
+
+  class Dog
+    class << self
+      # Demonstrates another class method.
+      def another_class_method
+        :still_another_way
+      end
+    end
+  end
+
+  # Checks heres still another way to write class methods.
+  def test_heres_still_another_way_to_write_class_methods
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:heres_still_another_way_to_write_class_methods_one),
+                 Dog.another_class_method
+  end
+
+  # THINK ABOUT IT:
+  #
+  # The two major ways to write class methods are:
+  #   class Demo
+  #     def self.method
+  #     end
+  #
+  #     class << self
+  #       def class_methods
+  #       end
+  #     end
+  #   end
+  #
+  # Which do you prefer and why?
+  # Are there times you might prefer one over the other?
+
+  # ------------------------------------------------------------------
+
+  # Checks heres an easy way to call class methods from instance methods.
+  def test_heres_an_easy_way_to_call_class_methods_from_instance_methods
+    fido = Dog.new
+
+    assert_equal Exercises::AboutClassMethods.koans.fetch(:heres_an_easy_way_to_call_class_methods_from_instance_methods_one),
+                 fido.class.another_class_method
+  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::AboutClassMethods.koans.fetch(key), error.class
+    error
+  end
+end
+
+# rubocop:enable Lint/EmptyClass, Naming/ConstantName, Style/ClassMethods, Style/TrivialAccessors