rkoans 0.0.1 → 0.1.0

data/exercises/about-class-methods/about_class_methods.rb

@@ -0,0 +1,105 @@
+# 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 class methods examples.
+  class AboutClassMethods
+    # 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
+      {
+        # Objects are objects.
+        # fido = Dog.new
+        # assert_equal __, fido.is_a?(Object)
+        # Predict: fido.is_a?(Object)
+        objects_are_objects_one: :fill_me_in,
+        # Classes are classes.
+        # assert_equal __, Dog.is_a?(Class)
+        # Predict: Dog.is_a?(Class)
+        classes_are_classes_one: :fill_me_in,
+        # Classes are objects too.
+        # assert_equal __, Dog.is_a?(Object)
+        # Predict: Dog.is_a?(Object)
+        classes_are_objects_too_one: :fill_me_in,
+        # Objects have methods.
+        # fido = Dog.new
+        # assert_equal __, fido.methods.any?
+        # Predict: fido.methods.any?
+        objects_have_methods_one: :fill_me_in,
+        # Classes have methods.
+        # assert_equal __, Dog.methods.any?
+        # Predict: Dog.methods.any?
+        classes_have_methods_one: :fill_me_in,
+        # You can define methods on individual objects.
+        # fido = Dog.new
+        # def fido.wag
+        # :fidos_wag
+        # end
+        # assert_equal __, fido.wag
+        # Predict: fido.wag
+        you_can_define_methods_on_individual_objects_one: :fill_me_in,
+        # Other objects are not affected by these singleton methods.
+        # fido = Dog.new
+        # rover = Dog.new
+        # def fido.wag
+        # :fidos_wag
+        # end
+        # assert_raise(___) do
+        # rover.wag
+        # end
+        # Predict: exception class from: rover.wag
+        other_objects_are_not_affected_by_these_singleton_methods_one: :fill_me_in,
+        # Since classes are objects you can define singleton methods on them too.
+        # assert_equal __, Dog2.wag
+        # Predict: Dog2.wag
+        since_classes_are_objects_you_can_define_singleton_methods_on_them_too_one: :fill_me_in,
+        # Class methods are independent of instance methods.
+        # fido = Dog2.new
+        # assert_equal __, fido.wag
+        # assert_equal __, Dog2.wag
+        # Predict: fido.wag
+        class_methods_are_independent_of_instance_methods_one: :fill_me_in,
+        # Predict: Dog2.wag
+        class_methods_are_independent_of_instance_methods_two: :fill_me_in,
+        # Classes and instances do not share instance variables.
+        # fido = Dog.new
+        # fido.name = "Fido"
+        # assert_equal __, fido.name
+        # assert_equal __, Dog.name
+        # Predict: fido.name
+        classes_and_instances_do_not_share_instance_variables_one: :fill_me_in,
+        # Predict: Dog.name
+        classes_and_instances_do_not_share_instance_variables_two: :fill_me_in,
+        # You can define class methods inside the class.
+        # assert_equal __, Dog.a_class_method
+        # Predict: Dog.a_class_method
+        you_can_define_class_methods_inside_the_class_one: :fill_me_in,
+        # Class statements return the value of their last expression.
+        # assert_equal __, LastExpressionInClassStatement
+        # Predict: LastExpressionInClassStatement
+        class_statements_return_the_value_of_their_last_expression_one: :fill_me_in,
+        # Self while inside class is class object not instance.
+        # assert_equal __, Dog == SelfInsideOfClassStatement
+        # Predict: Dog == SelfInsideOfClassStatement
+        self_while_inside_class_is_class_object_not_instance_one: :fill_me_in,
+        # You can use self instead of an explicit reference to dog.
+        # assert_equal __, Dog.class_method2
+        # Predict: Dog.class_method2
+        you_can_use_self_instead_of_an_explicit_reference_to_dog_one: :fill_me_in,
+        # Heres still another way to write class methods.
+        # assert_equal __, Dog.another_class_method
+        # Predict: Dog.another_class_method
+        heres_still_another_way_to_write_class_methods_one: :fill_me_in,
+        # Heres an easy way to call class methods from instance methods.
+        # fido = Dog.new
+        # assert_equal __, fido.class.another_class_method
+        # Predict: fido.class.another_class_method
+        heres_an_easy_way_to_call_class_methods_from_instance_methods_one: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-class-methods/brief.md

@@ -0,0 +1,73 @@
+# About Class Methods
+
+Replace each `:fill_me_in` in `about_class_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 `AboutClassMethodsTest`.
+
+```ruby
+class Dog
+  end
+
+class Dog2
+    def wag
+      :instance_level_wag
+    end
+  end
+
+class Dog
+    attr_accessor :name
+  end
+
+class Dog
+    def Dog.a_class_method
+      :dogs_class_method
+    end
+  end
+
+class Dog
+                                     21
+                                   end
+
+class Dog
+                                 self
+                               end
+
+class Dog
+    def self.class_method2
+      :another_way_to_write_class_methods
+    end
+  end
+
+class Dog
+    class << self
+      def another_class_method
+        :still_another_way
+      end
+    end
+  end
+
+def fido.wag
+      :fidos_wag
+    end
+
+def fido.wag
+      :fidos_wag
+    end
+
+def Dog2.wag
+    :class_level_wag
+  end
+
+def Dog.name
+    @name
+  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-class-methods/hint.md

@@ -0,0 +1,8 @@
+# Hint
+
+Classes are objects too. A class method belongs to the class object, while
+an instance method belongs to instances. Class-object instance variables are
+separate from an instance's variables.
+
+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-classes/about_classes.rb

@@ -0,0 +1,131 @@
+# 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 classes examples.
+  class AboutClasses
+    # 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
+      {
+        # Instances of classes can be created with new.
+        # fido = Dog.new
+        # assert_equal __, fido.class
+        # Predict: fido.class
+        instances_of_classes_can_be_created_with_new_one: :fill_me_in,
+        # Instance variables can be set by assigning to them.
+        # fido = Dog2.new
+        # assert_equal __, fido.instance_variables
+        # fido.set_name("Fido")
+        # assert_equal __, fido.instance_variables
+        # Predict: fido.instance_variables
+        instance_variables_can_be_set_by_assigning_to_them_one: :fill_me_in,
+        # Predict: fido.instance_variables
+        instance_variables_can_be_set_by_assigning_to_them_two: :fill_me_in,
+        # Instance variables cannot be accessed outside the class.
+        # fido = Dog2.new
+        # fido.set_name("Fido")
+        # assert_raise(___) do
+        # fido.name
+        # end
+        # assert_raise(___) do
+        # eval "fido.@name"
+        # NOTE: Using eval because the above line is a syntax error.
+        # end
+        # Predict: exception class from: fido.name
+        instance_variables_cannot_be_accessed_outside_the_class_one: :fill_me_in,
+        # Predict: exception class from: eval "fido.@name"
+        instance_variables_cannot_be_accessed_outside_the_class_two: :fill_me_in,
+        # You can politely ask for instance variable values.
+        # fido = Dog2.new
+        # fido.set_name("Fido")
+        # assert_equal __, fido.instance_variable_get("@name")
+        # Predict: fido.instance_variable_get("@name")
+        you_can_politely_ask_for_instance_variable_values_one: :fill_me_in,
+        # You can rip the value out using instance eval.
+        # fido = Dog2.new
+        # fido.set_name("Fido")
+        # assert_equal __, fido.instance_eval("@name")  # string version
+        # assert_equal __, fido.instance_eval { @name }
+        # Predict: fido.instance_eval("@name")
+        you_can_rip_the_value_out_using_instance_eval_one: :fill_me_in,
+        # Predict: fido.instance_eval { @name }
+        you_can_rip_the_value_out_using_instance_eval_two: :fill_me_in,
+        # You can create accessor methods to return instance variables.
+        # fido = Dog3.new
+        # fido.set_name("Fido")
+        # assert_equal __, fido.name
+        # Predict: fido.name
+        you_can_create_accessor_methods_to_return_instance_variables_one: :fill_me_in,
+        # Attr reader will automatically define an accessor.
+        # fido = Dog4.new
+        # fido.set_name("Fido")
+        # assert_equal __, fido.name
+        # Predict: fido.name
+        attr_reader_will_automatically_define_an_accessor_one: :fill_me_in,
+        # Attr accessor will automatically define both read and write accessors.
+        # fido = Dog5.new
+        # fido.name = "Fido"
+        # assert_equal __, fido.name
+        # Predict: fido.name
+        attr_accessor_will_automatically_define_both_read_and_write_accessors_one: :fill_me_in,
+        # Initialize provides initial values for instance variables.
+        # fido = Dog6.new("Fido")
+        # assert_equal __, fido.name
+        # Predict: fido.name
+        initialize_provides_initial_values_for_instance_variables_one: :fill_me_in,
+        # Args to new must match initialize.
+        # assert_raise(___) do
+        # Dog6.new
+        # end
+        # Predict: exception class from: Dog6.new
+        args_to_new_must_match_initialize_one: :fill_me_in,
+        # Different objects have different instance variables.
+        # fido = Dog6.new("Fido")
+        # rover = Dog6.new("Rover")
+        # assert_equal __, rover.name != fido.name
+        # Predict: rover.name != fido.name
+        different_objects_have_different_instance_variables_one: :fill_me_in,
+        # Inside a method self refers to the containing object.
+        # fido = Dog7.new("Fido")
+        # fidos_self = fido.get_self
+        # assert_equal __, fidos_self.equal?(fido)
+        # Predict: fidos_self.equal?(fido)
+        inside_a_method_self_refers_to_the_containing_object_one: :fill_me_in,
+        # To s provides a string version of the object.
+        # fido = Dog7.new("Fido")
+        # assert_equal __, fido.to_s
+        # Predict: fido.to_s
+        to_s_provides_a_string_version_of_the_object_one: :fill_me_in,
+        # To s is used in string interpolation.
+        # fido = Dog7.new("Fido")
+        # assert_equal __, "My dog is #{fido}"
+        # Predict: "My dog is #{fido}"
+        to_s_is_used_in_string_interpolation_one: :fill_me_in,
+        # Inspect provides a more complete string version.
+        # fido = Dog7.new("Fido")
+        # assert_equal __, fido.inspect
+        # Predict: fido.inspect
+        inspect_provides_a_more_complete_string_version_one: :fill_me_in,
+        # All objects support to s and inspect.
+        # array = [1,2,3]
+        # assert_equal __, array.to_s
+        # assert_equal __, array.inspect
+        # assert_equal __, "STRING".to_s
+        # assert_equal __, "STRING".inspect
+        # Predict: array.to_s
+        all_objects_support_to_s_and_inspect_one: :fill_me_in,
+        # Predict: array.inspect
+        all_objects_support_to_s_and_inspect_two: :fill_me_in,
+        # Predict: "STRING".to_s
+        all_objects_support_to_s_and_inspect_three: :fill_me_in,
+        # Predict: "STRING".inspect
+        all_objects_support_to_s_and_inspect_four: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-classes/brief.md

@@ -0,0 +1,73 @@
+# About Classes
+
+Replace each `:fill_me_in` in `about_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 `AboutClassesTest`.
+
+```ruby
+class Dog
+  end
+
+class Dog2
+    def set_name(a_name)
+      @name = a_name
+    end
+  end
+
+class Dog3
+    def set_name(a_name)
+      @name = a_name
+    end
+    def name
+      @name
+    end
+  end
+
+class Dog4
+    attr_reader :name
+
+    def set_name(a_name)
+      @name = a_name
+    end
+  end
+
+class Dog5
+    attr_accessor :name
+  end
+
+class Dog6
+    attr_reader :name
+    def initialize(initial_name)
+      @name = initial_name
+    end
+  end
+
+class Dog7
+    attr_reader :name
+
+    def initialize(initial_name)
+      @name = initial_name
+    end
+
+    def get_self
+      self
+    end
+
+    def to_s
+      @name
+    end
+
+    def inspect
+      "<Dog named '#{name}'>"
+    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-classes/hint.md

@@ -0,0 +1,7 @@
+# Hint
+
+Follow construction, instance variables, accessors, and the receiver `self`.
+Each object owns its instance variables. Compare `to_s` with `inspect`.
+
+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-constants/about_constants.rb

@@ -0,0 +1,49 @@
+# 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 constants examples.
+  class AboutConstants
+    # 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
+      {
+        # Nested constants may also be referenced with relative paths.
+        # assert_equal __, C
+        # Predict: C
+        nested_constants_may_also_be_referenced_with_relative_paths_one: :fill_me_in,
+        # Top level constants are referenced by double colons.
+        # assert_equal __, ::C
+        # Predict: ::C
+        top_level_constants_are_referenced_by_double_colons_one: :fill_me_in,
+        # Nested constants are referenced by their complete path.
+        # assert_equal __, AboutConstantsTest::C
+        # assert_equal __, ::AboutConstantsTest::C
+        # Predict: AboutConstantsTest::C
+        nested_constants_are_referenced_by_their_complete_path_one: :fill_me_in,
+        # Predict: ::AboutConstantsTest::C
+        nested_constants_are_referenced_by_their_complete_path_two: :fill_me_in,
+        # Nested classes inherit constants from enclosing classes.
+        # assert_equal __, Animal::NestedAnimal.new.legs_in_nested_animal
+        # Predict: Animal::NestedAnimal.new.legs_in_nested_animal
+        nested_classes_inherit_constants_from_enclosing_classes_one: :fill_me_in,
+        # Subclasses inherit constants from parent classes.
+        # assert_equal __, Reptile.new.legs_in_reptile
+        # Predict: Reptile.new.legs_in_reptile
+        subclasses_inherit_constants_from_parent_classes_one: :fill_me_in,
+        # Who wins with both nested and inherited constants.
+        # assert_equal __, MyAnimals::Bird.new.legs_in_bird
+        # Predict: MyAnimals::Bird.new.legs_in_bird
+        who_wins_with_both_nested_and_inherited_constants_one: :fill_me_in,
+        # Who wins with explicit scoping on class definition.
+        # assert_equal __, MyAnimals::Oyster.new.legs_in_oyster
+        # Predict: MyAnimals::Oyster.new.legs_in_oyster
+        who_wins_with_explicit_scoping_on_class_definition_one: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-constants/brief.md

@@ -0,0 +1,51 @@
+# About Constants
+
+Replace each `:fill_me_in` in `about_constants.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 `AboutConstantsTest`.
+
+```ruby
+class Animal
+    LEGS = 4
+    def legs_in_animal
+      LEGS
+    end
+
+    class NestedAnimal
+      def legs_in_nested_animal
+        LEGS
+      end
+    end
+  end
+
+class Reptile < Animal
+    def legs_in_reptile
+      LEGS
+    end
+  end
+
+class MyAnimals
+    LEGS = 2
+
+    class Bird < Animal
+      def legs_in_bird
+        LEGS
+      end
+    end
+  end
+
+class MyAnimals::Oyster < Animal
+    def legs_in_oyster
+      LEGS
+    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-constants/hint.md

@@ -0,0 +1,7 @@
+# Hint
+
+Trace both lexical nesting and inheritance. A leading `::` starts at the
+top level. Compare nested class syntax with `class Outer::Inner` syntax.
+
+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-control-statements/about_control_statements.rb

@@ -0,0 +1,152 @@
+# 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 control statements examples.
+  class AboutControlStatements
+    # 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
+      {
+        # If then else statements.
+        # if true
+        # result = :true_value
+        # else
+        # result = :false_value
+        # end
+        # assert_equal __, result
+        # Predict: result
+        if_then_else_statements_one: :fill_me_in,
+        # If then statements.
+        # result = :default_value
+        # if true
+        # result = :true_value
+        # end
+        # assert_equal __, result
+        # Predict: result
+        if_then_statements_one: :fill_me_in,
+        # If statements return values.
+        # value = if true
+        # :true_value
+        # else
+        # :false_value
+        # end
+        # assert_equal __, value
+        # value = if false
+        # :true_value
+        # else
+        # :false_value
+        # end
+        # assert_equal __, value
+        # Predict: value
+        if_statements_return_values_one: :fill_me_in,
+        # Predict: value
+        if_statements_return_values_two: :fill_me_in,
+        # If statements with no else with false condition return value.
+        # value = if false
+        # :true_value
+        # end
+        # assert_equal __, value
+        # Predict: value
+        if_statements_with_no_else_with_false_condition_return_value_one: :fill_me_in,
+        # Condition operators.
+        # assert_equal __, (true ? :true_value : :false_value)
+        # assert_equal __, (false ? :true_value : :false_value)
+        # Predict: (true ? :true_value : :false_value)
+        condition_operators_one: :fill_me_in,
+        # Predict: (false ? :true_value : :false_value)
+        condition_operators_two: :fill_me_in,
+        # If statement modifiers.
+        # result = :default_value
+        # result = :true_value if true
+        # assert_equal __, result
+        # Predict: result
+        if_statement_modifiers_one: :fill_me_in,
+        # Unless statement.
+        # result = :default_value
+        # unless false    # same as saying 'if !false', which evaluates as 'if true'
+        # result = :false_value
+        # end
+        # assert_equal __, result
+        # Predict: result
+        unless_statement_one: :fill_me_in,
+        # 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 __, result
+        # Predict: result
+        unless_statement_evaluate_true_one: :fill_me_in,
+        # Unless statement modifier.
+        # result = :default_value
+        # result = :false_value unless false
+        # assert_equal __, result
+        # Predict: result
+        unless_statement_modifier_one: :fill_me_in,
+        # While statement.
+        # i = 1
+        # result = 1
+        # while i <= 10
+        # result = result * i
+        # i += 1
+        # end
+        # assert_equal __, result
+        # Predict: result
+        while_statement_one: :fill_me_in,
+        # Break statement.
+        # i = 1
+        # result = 1
+        # while true
+        # break unless i <= 10
+        # result = result * i
+        # i += 1
+        # end
+        # assert_equal __, result
+        # Predict: result
+        break_statement_one: :fill_me_in,
+        # Break statement returns values.
+        # i = 1
+        # result = while i <= 10
+        # break i if i % 2 == 0
+        # i += 1
+        # end
+        # assert_equal __, result
+        # Predict: result
+        break_statement_returns_values_one: :fill_me_in,
+        # Next statement.
+        # i = 0
+        # result = []
+        # while i < 10
+        # i += 1
+        # next if (i % 2) == 0
+        # result << i
+        # end
+        # assert_equal __, result
+        # Predict: result
+        next_statement_one: :fill_me_in,
+        # For statement.
+        # array = ["fish", "and", "chips"]
+        # result = []
+        # for item in array
+        # result << item.upcase
+        # end
+        # assert_equal [__, __, __], result
+        # Predict: result
+        for_statement_one: :fill_me_in,
+        # Times statement.
+        # sum = 0
+        # 10.times do
+        # sum += 1
+        # end
+        # assert_equal __, sum
+        # Predict: sum
+        times_statement_one: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-control-statements/brief.md

@@ -0,0 +1,9 @@
+# About Control Statements
+
+Replace each `:fill_me_in` in `about_control_statements.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.
+
+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-control-statements/hint.md

@@ -0,0 +1,7 @@
+# Hint
+
+Conditionals and loops return values. Watch what `break` returns, what
+`next` skips, and whether an `if` without an `else` takes its branch.
+
+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.