rkoans 0.0.1 → 0.1.0

data/exercises/about-nil/about_nil.rb

@@ -0,0 +1,29 @@
+# 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
+  # Predicts nil conversions and missing-method behavior.
+  class AboutNil
+    # Replace each :fill_me_in with the result described by its example.
+    # @return [Hash<Symbol, Boolean | String | Class>]
+    def self.koans
+      {
+        # nil.is_a?(Object)
+        nil_object: :fill_me_in,
+        # exception class raised by nil.some_method_nil_doesnt_know_about
+        missing_method_error: :fill_me_in,
+        # a nonempty substring of that exception message
+        message_fragment: :fill_me_in,
+        # nil.nil?
+        nil_predicate: :fill_me_in,
+        # nil.to_s
+        string_value: :fill_me_in,
+        # nil.inspect
+        inspected_value: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-nil/brief.md

@@ -0,0 +1,12 @@
+# About Nil
+
+Replace each `:fill_me_in` in `about_nil.rb` with the result described by its
+example. Predict whether nil is an object, its supported conversions, and what
+happens when a method it does not know is called.
+
+For `missing_method_error`, supply the exception class. For `message_fragment`,
+supply a nonempty string found in the exception's message. Predict a fragment
+rather than the full message so diagnostic formatting can vary.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-nil/hint.md

@@ -0,0 +1,11 @@
+# Hint
+
+Nil is an object with methods. Compare `nil.nil?`, `nil.to_s`, and `nil.inspect`
+in IRB, paying attention to an empty string versus a string spelling `nil`.
+
+Call `nil.some_method_nil_doesnt_know_about` and inspect the exception's class
+and message. The error names the missing method. Use a nonempty message fragment
+as a string, without regular-expression delimiters.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-objects/about_objects.rb

@@ -0,0 +1,51 @@
+# 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
+  # Predicts conversion, inspection, and object identity.
+  class AboutObjects
+    # Replace each :fill_me_in with the result of its example.
+    # @return [Hash<Symbol, Boolean | String | Integer | Class>]
+    def self.koans
+      {
+        # 1.is_a?(Object)
+        integer_object: :fill_me_in,
+        # 1.5.is_a?(Object)
+        float_object: :fill_me_in,
+        # 'string'.is_a?(Object)
+        string_object: :fill_me_in,
+        # nil.is_a?(Object)
+        nil_object: :fill_me_in,
+        # Object.is_a?(Object)
+        class_object: :fill_me_in,
+        # 123.to_s
+        integer_string: :fill_me_in,
+        # nil.to_s
+        nil_string: :fill_me_in,
+        # 123.inspect
+        integer_inspect: :fill_me_in,
+        # nil.inspect
+        nil_inspect: :fill_me_in,
+        # obj = Object.new; obj.object_id.class
+        id_type: :fill_me_in,
+        # obj = Object.new; another_obj = Object.new; obj.object_id != another_obj.object_id
+        distinct_ids: :fill_me_in,
+        # 0.object_id
+        zero_id: :fill_me_in,
+        # 1.object_id
+        one_id: :fill_me_in,
+        # 2.object_id
+        two_id: :fill_me_in,
+        # 100.object_id
+        hundred_id: :fill_me_in,
+        # obj = Object.new; copy = obj.clone; obj != copy
+        clone_unequal: :fill_me_in,
+        # obj = Object.new; copy = obj.clone; obj.object_id != copy.object_id
+        clone_distinct_id: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-objects/brief.md

@@ -0,0 +1,14 @@
+# About Objects
+
+Replace each `:fill_me_in` in `about_objects.rb` with the result of its example.
+Answers include booleans, strings, integers, and the class of an object ID.
+
+Explore ordinary values as objects, `to_s` versus `inspect`, identifiers for
+distinct objects, and what happens when a plain object is cloned.
+
+The small-integer ID examples observe MRI's representation on this course's
+runtime. Their numeric pattern is an implementation detail; use identity
+comparisons when reasoning about ordinary objects.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-objects/hint.md

@@ -0,0 +1,12 @@
+# Hint
+
+Compare `nil.to_s` with `nil.inspect` in IRB. One is a string conversion; the
+other is a representation useful for inspecting a value.
+
+An object keeps its ID while it is alive, and distinct live objects have
+distinct IDs. A second variable can point to the same object; `clone` creates
+a different object. Inspect IDs for `0`, `1`, `2`, and `100` to find the pattern
+used for these small integers on MRI.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-open-classes/about_open_classes.rb

@@ -0,0 +1,38 @@
+# 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 open classes examples.
+  class AboutOpenClasses
+    # Replace each :fill_me_in with the result of the described expression.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans
+      {
+        # As defined dogs do bark.
+        # fido = Dog.new
+        # assert_equal __, fido.bark
+        # Predict: fido.bark
+        as_defined_dogs_do_bark_one: :fill_me_in,
+        # After reopening dogs can both wag and bark.
+        # fido = Dog.new
+        # assert_equal __, fido.wag
+        # assert_equal __, fido.bark
+        # Predict: fido.wag
+        after_reopening_dogs_can_both_wag_and_bark_one: :fill_me_in,
+        # Predict: fido.bark
+        after_reopening_dogs_can_both_wag_and_bark_two: :fill_me_in,
+        # Even existing built in classes can be reopened.
+        # assert_equal __, 1.answer_to_life_universe_and_everything?
+        # assert_equal __, 42.answer_to_life_universe_and_everything?
+        # Predict: 1.answer_to_life_universe_and_everything?
+        even_existing_built_in_classes_can_be_reopened_one: :fill_me_in,
+        # Predict: 42.answer_to_life_universe_and_everything?
+        even_existing_built_in_classes_can_be_reopened_two: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-open-classes/brief.md

@@ -0,0 +1,34 @@
+# About Open Classes
+
+Replace each `:fill_me_in` in `about_open_classes.rb` with the predicted result.
+Each field identifies its example. Run the checks after edits to investigate the
+next prediction. Answers include the Ruby values and exception classes shown by
+the examples. Read the setup comments before evaluating an expression.
+
+## Example definitions
+
+These definitions supply the objects and methods used by the prediction examples.
+They run in the check class `AboutOpenClassesTest`.
+
+```ruby
+class Dog
+    def bark
+      "WOOF"
+    end
+  end
+
+class Dog
+    def wag
+      "HAPPY"
+    end
+  end
+
+class ::Integer
+    def answer_to_life_universe_and_everything?
+      self == 42
+    end
+  end
+```
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-open-classes/hint.md

@@ -0,0 +1,7 @@
+# Hint
+
+Reopening a class adds methods to that same class. Existing instances see
+the new instance methods too. A leading `::` refers to a top-level class.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-pattern-matching/about_pattern_matching.rb

@@ -0,0 +1,106 @@
+# 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 pattern matching examples.
+  class AboutPatternMatching
+    # Replace each :fill_me_in with the result of the described expression.
+    # @return [Hash<Symbol, Object>]
+    # This method is an answer table, not a sequence of operations.
+    def self.koans # rubocop:disable Metrics/MethodLength
+      {
+        # Pattern may not match.
+        # begin
+        # case [true, false]
+        # in [a, b] if a == b # The condition after pattern is called guard.
+        # :match
+        # end
+        # rescue NoMatchingPatternError => ex
+        # What exception has been caught?
+        # assert_equal __, ex.class
+        # end
+        # Predict: ex.class
+        pattern_may_not_match_one: :fill_me_in,
+        # We can use else.
+        # result = case [true, false]
+        # in [a, b] if a == b
+        # :match
+        # else
+        # :no_match
+        # end
+        # assert_equal __, result
+        # Predict: result
+        we_can_use_else_one: :fill_me_in,
+        # Value pattern.
+        # assert_equal __, value_pattern(0)
+        # assert_equal __, value_pattern(5)
+        # assert_equal __, value_pattern(100)
+        # assert_equal __, value_pattern('Not a Number!')
+        # Predict: value_pattern(0)
+        value_pattern_one: :fill_me_in,
+        # Predict: value_pattern(5)
+        value_pattern_two: :fill_me_in,
+        # Predict: value_pattern(100)
+        value_pattern_three: :fill_me_in,
+        # Predict: value_pattern('Not a Number!')
+        value_pattern_four: :fill_me_in,
+        # Variable pattern with binding.
+        # assert_equal __, variable_pattern_with_binding(1)
+        # Predict: variable_pattern_with_binding(1)
+        variable_pattern_with_binding_one: :fill_me_in,
+        # Variable pattern with pin.
+        # assert_equal __, variable_pattern_with_pin(1)
+        # Predict: variable_pattern_with_pin(1)
+        variable_pattern_with_pin_one: :fill_me_in,
+        # Pattern with dropping.
+        # assert_equal __, pattern_with_dropping(['I will not be checked', 2])
+        # assert_equal __, pattern_with_dropping(['I will not be checked', 'But I will!'])
+        # Predict: pattern_with_dropping(['I will not be checked', 2])
+        pattern_with_dropping_one: :fill_me_in,
+        # Predict: pattern_with_dropping(['I will not be checked', 'But I will!'])
+        pattern_with_dropping_two: :fill_me_in,
+        # Alternative pattern.
+        # assert_equal __, alternative_pattern(0)
+        # assert_equal __, alternative_pattern(false)
+        # assert_equal __, alternative_pattern(nil)
+        # assert_equal __, alternative_pattern(4)
+        # Predict: alternative_pattern(0)
+        alternative_pattern_one: :fill_me_in,
+        # Predict: alternative_pattern(false)
+        alternative_pattern_two: :fill_me_in,
+        # Predict: alternative_pattern(nil)
+        alternative_pattern_three: :fill_me_in,
+        # Predict: alternative_pattern(4)
+        alternative_pattern_four: :fill_me_in,
+        # As pattern.
+        # assert_equal __, as_pattern
+        # Predict: as_pattern
+        as_pattern_one: :fill_me_in,
+        # Array pattern.
+        # assert_equal __, array_pattern(Deconstructible.new('abcd'))
+        # assert_equal __, array_pattern(Deconstructible.new('123'))
+        # Predict: array_pattern(Deconstructible.new('abcd'))
+        array_pattern_one: :fill_me_in,
+        # Predict: array_pattern(Deconstructible.new('123'))
+        array_pattern_two: :fill_me_in,
+        # Hash pattern.
+        # assert_equal __, hash_pattern(LetterAccountant.new('aaabbc'))
+        # assert_equal __, hash_pattern(LetterAccountant.new('xyz'))
+        # Predict: hash_pattern(LetterAccountant.new('aaabbc'))
+        hash_pattern_one: :fill_me_in,
+        # Predict: hash_pattern(LetterAccountant.new('xyz'))
+        hash_pattern_two: :fill_me_in,
+        # Hash pattern with sugar.
+        # assert_equal __, hash_pattern_with_sugar(LetterAccountant.new('aaabbc'))
+        # assert_equal __, hash_pattern_with_sugar(LetterAccountant.new('xyz'))
+        # Predict: hash_pattern_with_sugar(LetterAccountant.new('aaabbc'))
+        hash_pattern_with_sugar_one: :fill_me_in,
+        # Predict: hash_pattern_with_sugar(LetterAccountant.new('xyz'))
+        hash_pattern_with_sugar_two: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-pattern-matching/brief.md

@@ -0,0 +1,124 @@
+# About Pattern Matching
+
+Replace each `:fill_me_in` in `about_pattern_matching.rb` with the predicted result.
+Each field identifies its example. Run the checks after edits to investigate the
+next prediction. Answers include the Ruby values and exception classes shown by
+the examples. Read the setup comments before evaluating an expression.
+
+## Example definitions
+
+These definitions supply the objects and methods used by the prediction examples.
+They run in the check class `AboutPatternMatchingTest`.
+
+```ruby
+class Deconstructible
+    def initialize(str)
+      @data = str
+    end
+
+    def deconstruct
+      @data&.split('')
+    end
+  end
+
+class LetterAccountant
+    def initialize(str)
+      @data = str
+    end
+
+    def deconstruct_keys(keys)
+      # we will count number of occurrences of each key in our data
+      keys.map { |key| [key, @data.count(key.to_s)] }.to_h
+    end
+  end
+
+def value_pattern(variable)
+    case variable
+    in 0
+      :match_exact_value
+    in 1..10
+      :match_in_range
+    in Integer
+      :match_with_class
+    else
+      :no_match
+    end
+  end
+
+def variable_pattern_with_binding(variable)
+    case 0
+    in variable
+      variable
+    else
+      :no_match
+    end
+  end
+
+def variable_pattern_with_pin(variable)
+    case 0
+    in ^variable
+      variable
+    else
+      :no_match
+    end
+  end
+
+def pattern_with_dropping(variable)
+    case variable
+    in [_, 2]
+      :match
+    else
+      :no_match
+    end
+  end
+
+def alternative_pattern(variable)
+    case variable
+    in 0 | false | nil
+      :match
+    else
+      :no_match
+    end
+  end
+
+def as_pattern
+    a = 'First I was afraid'
+
+    case 'I was petrified'
+    in String => a
+      a
+    else
+      :no_match
+    end
+  end
+
+def array_pattern(deconstructible)
+    case deconstructible
+    in 'a', *res, 'd'
+      res
+    else
+      :no_match
+    end
+  end
+
+def hash_pattern(deconstructible_as_hash)
+    case deconstructible_as_hash
+    in {a: a, b: b}
+      [a, b]
+    else
+      :no_match
+    end
+  end
+
+def hash_pattern_with_sugar(deconstructible_as_hash)
+    case deconstructible_as_hash
+    in a:, b:
+      [a, b]
+    else
+      :no_match
+    end
+  end
+```
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-pattern-matching/hint.md

@@ -0,0 +1,8 @@
+# Hint
+
+A pattern can match values, classes, arrays, or hashes. A bare variable binds
+a value; a pinned variable checks its existing value. A guard adds a condition
+after the structural match.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under
+CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md` for attribution and license terms.

data/exercises/about-proxy-object-project/about_proxy_object_project.rb

@@ -0,0 +1,43 @@
+# 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
+  # Records messages while transparently forwarding them to a target.
+  class AboutProxyObjectProject
+    # Forwards unknown public messages and records their names.
+    class Proxy
+      attr_reader :messages
+
+      # @param target [Object] receiver of forwarded messages
+      def initialize(target)
+        @target = target
+        @messages = []
+      end
+
+      # @return [Object] result of the target's public method
+      def method_missing(name, ...)
+        @target.public_send(name, ...)
+      end
+
+      # @return [Boolean] whether a message has been recorded
+      def called?(_name)
+        false
+      end
+
+      # @return [Integer] number of recorded calls to a message
+      def number_of_times_called(_name)
+        0
+      end
+
+      private
+
+      # Keeps introspection consistent with the target's public methods.
+      def respond_to_missing?(name, include_private = false)
+        super
+      end
+    end
+  end
+end

data/exercises/about-proxy-object-project/brief.md

@@ -0,0 +1,10 @@
+# Proxy Object Project
+
+Complete `Exercises::AboutProxyObjectProject::Proxy` in `about_proxy_object_project.rb`.
+Forward unknown messages to any target's public methods, preserving positional
+arguments, keywords, blocks and return values. Record message names in order.
+Expose `messages`, `called?(name)` and `number_of_times_called(name)`; reading
+these bookkeeping methods must not add messages. Unsupported messages should
+raise `NoMethodError`. Make `respond_to?` agree with the target's public API.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md`.

data/exercises/about-proxy-object-project/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Use `method_missing` with argument forwarding and `respond_to_missing?`. Count only forwarded messages.
+
+Adapted from Ruby Koans by Jim Weirich and Joe O'Brien, licensed under CC BY-NC-SA 3.0. See `THIRD_PARTY_NOTICES.md`.