rkoans 0.0.1 → 0.1.0

data/exercises/about-iteration/about_iteration.rb

@@ -0,0 +1,96 @@
+# 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
+    # 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
+      {
+        # Each is a method on arrays.
+        # assert_equal __, [].methods.include?(:each)
+        # Predict: [].methods.include?(:each)
+        each_is_a_method_on_arrays_one: :fill_me_in,
+        # Iterating with each.
+        # array = [1, 2, 3]
+        # sum = 0
+        # array.each do |item|
+        # sum += item
+        # end
+        # assert_equal __, sum
+        # Predict: sum
+        iterating_with_each_one: :fill_me_in,
+        # Each can use curly brace blocks too.
+        # array = [1, 2, 3]
+        # sum = 0
+        # array.each { |item| sum += item }
+        # assert_equal __, sum
+        # Predict: sum
+        each_can_use_curly_brace_blocks_too_one: :fill_me_in,
+        # Break works with each style iterations.
+        # array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        # sum = 0
+        # array.each do |item|
+        # break if item > 3
+        # sum += item
+        # end
+        # assert_equal __, sum
+        # Predict: sum
+        break_works_with_each_style_iterations_one: :fill_me_in,
+        # Collect transforms elements of an array.
+        # array = [1, 2, 3]
+        # new_array = array.collect { |item| item + 10 }
+        # assert_equal __, new_array
+        # NOTE: 'map' is another name for the 'collect' operation
+        # another_array = array.map { |item| item + 10 }
+        # assert_equal __, another_array
+        # Predict: new_array
+        collect_transforms_elements_of_an_array_one: :fill_me_in,
+        # Predict: another_array
+        collect_transforms_elements_of_an_array_two: :fill_me_in,
+        # Select selects certain items from an array.
+        # array = [1, 2, 3, 4, 5, 6]
+        # even_numbers = array.select { |item| (item % 2) == 0 }
+        # assert_equal __, even_numbers
+        # NOTE: 'find_all' is another name for the 'select' operation
+        # more_even_numbers = array.find_all { |item| (item % 2) == 0 }
+        # assert_equal __, more_even_numbers
+        # Predict: even_numbers
+        select_selects_certain_items_from_an_array_one: :fill_me_in,
+        # Predict: more_even_numbers
+        select_selects_certain_items_from_an_array_two: :fill_me_in,
+        # Find locates the first element matching a criteria.
+        # array = ["Jim", "Bill", "Clarence", "Doug", "Eli"]
+        # assert_equal __, array.find { |item| item.size > 4 }
+        # Predict: array.find { |item| item.size > 4 }
+        find_locates_the_first_element_matching_a_criteria_one: :fill_me_in,
+        # Inject will blow your mind.
+        # result = [2, 3, 4].inject(0) { |sum, item| sum + item }
+        # assert_equal __, result
+        # result2 = [2, 3, 4].inject(1) { |product, item| product * item }
+        # assert_equal __, result2
+        # Predict: result
+        inject_will_blow_your_mind_one: :fill_me_in,
+        # Predict: result2
+        inject_will_blow_your_mind_two: :fill_me_in,
+        # All iteration methods work on any collection not just arrays.
+        # result = (1..3).map { |item| item + 10 }
+        # assert_equal __, result
+        # Files act like a collection of lines
+        # with_example_file do |file|
+        # upcase_lines = file.map { |line| line.strip.upcase }
+        # assert_equal __, upcase_lines
+        # end
+        # Predict: result
+        all_iteration_methods_work_on_any_collection_not_just_arrays_one: :fill_me_in,
+        # Predict: upcase_lines
+        all_iteration_methods_work_on_any_collection_not_just_arrays_two: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-iteration/brief.md

@@ -0,0 +1,26 @@
+# About Iteration
+
+Replace each `:fill_me_in` in `about_iteration.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 `AboutIterationTest`.
+
+```ruby
+require 'tempfile'
+
+def with_example_file
+  Tempfile.create('rkoans-iteration') do |file|
+    file.write("this\nis\na\ntest\n")
+    file.rewind
+    yield file
+  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-iteration/hint.md

@@ -0,0 +1,6 @@
+# Hint
+
+Trace each collection operation separately. The file example contains four lines: this, is, a, test. A file enumerates lines, including their line endings.
+
+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-keyword-arguments/about_keyword_arguments.rb

@@ -0,0 +1,56 @@
+# 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
+    # 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
+      {
+        # Keyword arguments.
+        # assert_equal __, method_with_keyword_arguments.class
+        # assert_equal __, method_with_keyword_arguments
+        # assert_equal __, method_with_keyword_arguments(one: 'one')
+        # assert_equal __, method_with_keyword_arguments(two: 2)
+        # Predict: method_with_keyword_arguments.class
+        keyword_arguments_one: :fill_me_in,
+        # Predict: method_with_keyword_arguments
+        keyword_arguments_two: :fill_me_in,
+        # Predict: method_with_keyword_arguments(one: 'one')
+        keyword_arguments_three: :fill_me_in,
+        # Predict: method_with_keyword_arguments(two: 2)
+        keyword_arguments_four: :fill_me_in,
+        # Keyword arguments with wrong number of arguments.
+        # exception = assert_raise (___) do
+        # method_with_keyword_arguments_with_mandatory_argument
+        # end
+        # assert_match(/__/, exception.message)
+        # Predict: exception class from: method_with_keyword_arguments_with_mandatory_argument
+        keyword_arguments_with_wrong_number_of_arguments_one: :fill_me_in,
+        # Predict: exception.message
+        keyword_arguments_with_wrong_number_of_arguments_two: :fill_me_in,
+        # Mandatory keyword arguments.
+        # assert_equal __, method_with_mandatory_keyword_arguments(one: 'one')
+        # assert_equal __, method_with_mandatory_keyword_arguments(two: 2, one: 1)
+        # Predict: method_with_mandatory_keyword_arguments(one: 'one')
+        mandatory_keyword_arguments_one: :fill_me_in,
+        # Predict: method_with_mandatory_keyword_arguments(two: 2, one: 1)
+        mandatory_keyword_arguments_two: :fill_me_in,
+        # Mandatory keyword arguments without mandatory argument.
+        # exception = assert_raise(___) do
+        # method_with_mandatory_keyword_arguments
+        # end
+        # assert_match(/__/, exception.message)
+        # Predict: exception class from: method_with_mandatory_keyword_arguments
+        mandatory_keyword_arguments_without_mandatory_argument_one: :fill_me_in,
+        # Predict: exception.message
+        mandatory_keyword_arguments_without_mandatory_argument_two: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-keyword-arguments/brief.md

@@ -0,0 +1,28 @@
+# About Keyword Arguments
+
+Replace each `:fill_me_in` in `about_keyword_arguments.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 `AboutKeywordArgumentsTest`.
+
+```ruby
+def method_with_keyword_arguments(one: 1, two: 'two')
+    [one, two]
+  end
+
+def method_with_keyword_arguments_with_mandatory_argument(one, two: 2, three: 3)
+    [one, two, three]
+  end
+
+def method_with_mandatory_keyword_arguments(one:, two: 'two')
+    [one, two]
+  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-keyword-arguments/hint.md

@@ -0,0 +1,7 @@
+# Hint
+
+Separate positional arguments from keyword arguments. Defaults apply only to
+omitted keywords; a required keyword still has to be supplied by name.
+
+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-message-passing/about_message_passing.rb

@@ -0,0 +1,112 @@
+# 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 message passing examples.
+  class AboutMessagePassing
+    # 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
+      {
+        # Methods can be invoked more dynamically.
+        # mc = MessageCatcher.new
+        # assert mc.send("caught?")
+        # assert_equal __, mc.send("caught" + "?")    # What do you need to add to the first string?
+        # assert_equal __, mc.send("CAUGHT?".downcase)
+        # Predict: mc.send("caught" + "?")
+        methods_can_be_invoked_more_dynamically_one: :fill_me_in,
+        # Predict: mc.send("CAUGHT?".downcase)
+        methods_can_be_invoked_more_dynamically_two: :fill_me_in,
+        # Send with underscores will also send messages.
+        # mc = MessageCatcher.new
+        # assert_equal __, mc.__send__(:caught?)
+        # Predict: mc.__send__(:caught?)
+        send_with_underscores_will_also_send_messages_one: :fill_me_in,
+        # Classes can be asked if they know how to respond.
+        # mc = MessageCatcher.new
+        # assert_equal __, mc.respond_to?(:caught?)
+        # assert_equal __, mc.respond_to?(:does_not_exist)
+        # Predict: mc.respond_to?(:caught?)
+        classes_can_be_asked_if_they_know_how_to_respond_one: :fill_me_in,
+        # Predict: mc.respond_to?(:does_not_exist)
+        classes_can_be_asked_if_they_know_how_to_respond_two: :fill_me_in,
+        # Sending a message with arguments.
+        # mc = MessageCatcher.new
+        # assert_equal __, mc.add_a_payload
+        # assert_equal __, mc.send(:add_a_payload)
+        # assert_equal __, mc.add_a_payload(3, 4, nil, 6)
+        # assert_equal __, mc.send(:add_a_payload, 3, 4, nil, 6)
+        # Predict: mc.add_a_payload
+        sending_a_message_with_arguments_one: :fill_me_in,
+        # Predict: mc.send(:add_a_payload)
+        sending_a_message_with_arguments_two: :fill_me_in,
+        # Predict: mc.add_a_payload(3, 4, nil, 6)
+        sending_a_message_with_arguments_three: :fill_me_in,
+        # Predict: mc.send(:add_a_payload, 3, 4, nil, 6)
+        sending_a_message_with_arguments_four: :fill_me_in,
+        # Sending undefined messages to a typical object results in errors.
+        # typical = TypicalObject.new
+        # exception = assert_raise(___) do
+        # typical.foobar
+        # end
+        # assert_match(/foobar/, exception.message)
+        # Predict: exception class from: typical.foobar
+        sending_undefined_messages_to_a_typical_object_results_in_errors_one: :fill_me_in,
+        # Calling method missing causes the no method error.
+        # typical = TypicalObject.new
+        # exception = assert_raise(___) do
+        # typical.__send__(:method_missing, :foobar)
+        # end
+        # assert_match(/foobar/, exception.message)
+        # Predict: exception class from: typical.__send__(:method_missing, :foobar)
+        calling_method_missing_causes_the_no_method_error_one: :fill_me_in,
+        # All messages are caught.
+        # catcher = AllMessageCatcher.new
+        # assert_equal __, catcher.foobar
+        # assert_equal __, catcher.foobaz(1)
+        # assert_equal __, catcher.sum(1,2,3,4,5,6)
+        # Predict: catcher.foobar
+        all_messages_are_caught_one: :fill_me_in,
+        # Predict: catcher.foobaz(1)
+        all_messages_are_caught_two: :fill_me_in,
+        # Predict: catcher.sum(1,2,3,4,5,6)
+        all_messages_are_caught_three: :fill_me_in,
+        # Catching messages makes respond to lie.
+        # catcher = AllMessageCatcher.new
+        # assert_nothing_raised do
+        # catcher.any_method
+        # end
+        # assert_equal __, catcher.respond_to?(:any_method)
+        # Predict: catcher.respond_to?(:any_method)
+        catching_messages_makes_respond_to_lie_one: :fill_me_in,
+        # Foo method are caught.
+        # catcher = WellBehavedFooCatcher.new
+        # assert_equal __, catcher.foo_bar
+        # assert_equal __, catcher.foo_baz
+        # Predict: catcher.foo_bar
+        foo_method_are_caught_one: :fill_me_in,
+        # Predict: catcher.foo_baz
+        foo_method_are_caught_two: :fill_me_in,
+        # Non foo messages are treated normally.
+        # catcher = WellBehavedFooCatcher.new
+        # assert_raise(___) do
+        # catcher.normal_undefined_method
+        # end
+        # Predict: exception class from: catcher.normal_undefined_method
+        non_foo_messages_are_treated_normally_one: :fill_me_in,
+        # Explicitly implementing respond to lets objects tell the truth.
+        # catcher = WellBehavedFooCatcher.new
+        # assert_equal __, catcher.respond_to?(:foo_bar)
+        # assert_equal __, catcher.respond_to?(:something_else)
+        # Predict: catcher.respond_to?(:foo_bar)
+        explicitly_implementing_respond_to_lets_objects_tell_the_truth_one: :fill_me_in,
+        # Predict: catcher.respond_to?(:something_else)
+        explicitly_implementing_respond_to_lets_objects_tell_the_truth_two: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-message-passing/brief.md

@@ -0,0 +1,59 @@
+# About Message Passing
+
+Replace each `:fill_me_in` in `about_message_passing.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 `AboutMessagePassingTest`.
+
+```ruby
+class MessageCatcher
+    def caught?
+      true
+    end
+  end
+
+class MessageCatcher
+    def add_a_payload(*args)
+      args
+    end
+  end
+
+class TypicalObject
+  end
+
+class AllMessageCatcher
+    def method_missing(method_name, *args, &block)
+      "Someone called #{method_name} with <#{args.join(", ")}>"
+    end
+  end
+
+class WellBehavedFooCatcher
+    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
+
+class WellBehavedFooCatcher
+    private
+
+    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
+```
+
+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-message-passing/hint.md

@@ -0,0 +1,8 @@
+# Hint
+
+A method call sends a message. `send` and `__send__` accept a computed name.
+`method_missing` can handle unknown messages; `respond_to_missing?` lets
+introspection describe the same supported 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` for attribution and license terms.

data/exercises/about-methods/about_methods.rb

@@ -0,0 +1,104 @@
+# 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 methods examples.
+  class AboutMethods
+    # 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
+      {
+        # Calling global methods.
+        # assert_equal __, my_global_method(2,3)
+        # Predict: my_global_method(2,3)
+        calling_global_methods_one: :fill_me_in,
+        # Calling global methods without parentheses.
+        # result = my_global_method 2, 3
+        # assert_equal __, result
+        # Predict: result
+        calling_global_methods_without_parentheses_one: :fill_me_in,
+        # Sometimes missing parentheses are ambiguous.
+        # assert_equal __, eval("my_global_method(2, 3)")
+        # Predict: eval("my_global_method(2, 3)")
+        sometimes_missing_parentheses_are_ambiguous_one: :fill_me_in,
+        # Calling global methods with wrong number of arguments.
+        # exception = assert_raise(___) do
+        # my_global_method
+        # end
+        # assert_match(/__/, exception.message)
+        # exception = assert_raise(___) do
+        # my_global_method(1,2,3)
+        # end
+        # assert_match(/__/, exception.message)
+        # Predict: exception class from: my_global_method
+        calling_global_methods_with_wrong_number_of_arguments_one: :fill_me_in,
+        # Predict: exception.message
+        calling_global_methods_with_wrong_number_of_arguments_two: :fill_me_in,
+        # Predict: exception class from: my_global_method(1,2,3)
+        calling_global_methods_with_wrong_number_of_arguments_three: :fill_me_in,
+        # Predict: exception.message
+        calling_global_methods_with_wrong_number_of_arguments_four: :fill_me_in,
+        # Calling with default values.
+        # assert_equal [1, __], method_with_defaults(1)
+        # assert_equal [1, __], method_with_defaults(1, 2)
+        # Predict: method_with_defaults(1)
+        calling_with_default_values_one: :fill_me_in,
+        # Predict: method_with_defaults(1, 2)
+        calling_with_default_values_two: :fill_me_in,
+        # Calling with variable arguments.
+        # assert_equal __, method_with_var_args.class
+        # assert_equal __, method_with_var_args
+        # assert_equal __, method_with_var_args(:one)
+        # assert_equal __, method_with_var_args(:one, :two)
+        # Predict: method_with_var_args.class
+        calling_with_variable_arguments_one: :fill_me_in,
+        # Predict: method_with_var_args
+        calling_with_variable_arguments_two: :fill_me_in,
+        # Predict: method_with_var_args(:one)
+        calling_with_variable_arguments_three: :fill_me_in,
+        # Predict: method_with_var_args(:one, :two)
+        calling_with_variable_arguments_four: :fill_me_in,
+        # Method with explicit return.
+        # assert_equal __, method_with_explicit_return
+        # Predict: method_with_explicit_return
+        method_with_explicit_return_one: :fill_me_in,
+        # Method without explicit return.
+        # assert_equal __, method_without_explicit_return
+        # Predict: method_without_explicit_return
+        method_without_explicit_return_one: :fill_me_in,
+        # Calling methods in same class.
+        # assert_equal __, my_method_in_the_same_class(3,4)
+        # Predict: my_method_in_the_same_class(3,4)
+        calling_methods_in_same_class_one: :fill_me_in,
+        # Calling methods in same class with explicit receiver.
+        # assert_equal __, self.my_method_in_the_same_class(3,4)
+        # Predict: self.my_method_in_the_same_class(3,4)
+        calling_methods_in_same_class_with_explicit_receiver_one: :fill_me_in,
+        # Calling private methods without receiver.
+        # assert_equal __, my_private_method
+        # Predict: my_private_method
+        calling_private_methods_without_receiver_one: :fill_me_in,
+        # Calling private methods with an explicit receiver.
+        # assert_equal __, self.my_private_method
+        # Predict: self.my_private_method
+        calling_private_methods_with_an_explicit_receiver_one: :fill_me_in,
+        # Calling methods in other objects require explicit receiver.
+        # rover = Dog.new
+        # assert_equal __, rover.name
+        # Predict: rover.name
+        calling_methods_in_other_objects_require_explicit_receiver_one: :fill_me_in,
+        # Calling private methods in other objects.
+        # rover = Dog.new
+        # assert_raise(___) do
+        # rover.tail
+        # end
+        # Predict: exception class from: rover.tail
+        calling_private_methods_in_other_objects_one: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-methods/brief.md

@@ -0,0 +1,55 @@
+# About Methods
+
+Replace each `:fill_me_in` in `about_methods.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 `AboutMethodsTest`.
+
+```ruby
+class Dog
+    def name
+      "Fido"
+    end
+
+    private
+
+    def tail
+      "tail"
+    end
+  end
+
+def method_with_defaults(a, b=:default_value)
+    [a, b]
+  end
+
+def method_with_var_args(*args)
+    args
+  end
+
+def method_with_explicit_return
+    :a_non_return_value
+    return :return_value
+    :another_non_return_value
+  end
+
+def method_without_explicit_return
+    :a_non_return_value
+    :return_value
+  end
+
+def my_method_in_the_same_class(a, b)
+    a * b
+  end
+
+def my_private_method
+    "a secret"
+  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-methods/hint.md

@@ -0,0 +1,8 @@
+# Hint
+
+Observe defaults, splats, explicit returns, and the final expression of a method.
+Parentheses can disambiguate method arguments. Modern Ruby permits `self` when
+calling a private method, but another object cannot call that method directly.
+
+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-modules/about_modules.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
+  # Predictions for modules examples.
+  class AboutModules
+    # 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
+      {
+        # Cant instantiate modules.
+        # assert_raise(___) do
+        # Nameable.new
+        # end
+        # Predict: exception class from: Nameable.new
+        cant_instantiate_modules_one: :fill_me_in,
+        # Normal methods are available in the object.
+        # fido = Dog.new
+        # assert_equal __, fido.bark
+        # Predict: fido.bark
+        normal_methods_are_available_in_the_object_one: :fill_me_in,
+        # Module methods can affect instance variables in the object.
+        # fido = Dog.new
+        # assert_equal __, fido.name
+        # fido.set_name("Rover")
+        # assert_equal __, fido.name
+        # Predict: fido.name
+        module_methods_can_affect_instance_variables_in_the_object_one: :fill_me_in,
+        # Predict: fido.name
+        module_methods_can_affect_instance_variables_in_the_object_two: :fill_me_in,
+        # Classes can override module methods.
+        # fido = Dog.new
+        # assert_equal __, fido.here
+        # Predict: fido.here
+        classes_can_override_module_methods_one: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-modules/brief.md

@@ -0,0 +1,44 @@
+# About Modules
+
+Replace each `:fill_me_in` in `about_modules.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 `AboutModulesTest`.
+
+```ruby
+module Nameable
+    def set_name(new_name)
+      @name = new_name
+    end
+
+    def here
+      :in_module
+    end
+  end
+
+class Dog
+    include Nameable
+
+    attr_reader :name
+
+    def initialize
+      @name = "Fido"
+    end
+
+    def bark
+      "WOOF"
+    end
+
+    def here
+      :in_object
+    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-modules/hint.md

@@ -0,0 +1,8 @@
+# Hint
+
+Including a module makes its instance methods available to the receiving
+class. A class method definition with the same name takes precedence over an
+included instance method. Modules themselves are not instantiated with `new`.
+
+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.