rkoans 0.0.1 → 0.1.0

data/sig/exercises/about_class_methods.rbs

@@ -0,0 +1,62 @@
+# 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
+  class AboutClassMethods
+    type answers = {
+      objects_are_objects_one: (bool | :fill_me_in),
+      classes_are_classes_one: (bool | :fill_me_in),
+      classes_are_objects_too_one: (bool | :fill_me_in),
+      objects_have_methods_one: (bool | :fill_me_in),
+      classes_have_methods_one: (bool | :fill_me_in),
+      you_can_define_methods_on_individual_objects_one: (::Symbol | :fill_me_in),
+      other_objects_are_not_affected_by_these_singleton_methods_one: (singleton(::NoMethodError) | :fill_me_in),
+      since_classes_are_objects_you_can_define_singleton_methods_on_them_too_one: (::Symbol | :fill_me_in),
+      class_methods_are_independent_of_instance_methods_one: (::Symbol | :fill_me_in),
+      class_methods_are_independent_of_instance_methods_two: (::Symbol | :fill_me_in),
+      classes_and_instances_do_not_share_instance_variables_one: (::String | :fill_me_in),
+      classes_and_instances_do_not_share_instance_variables_two: (nil | :fill_me_in),
+      you_can_define_class_methods_inside_the_class_one: (::Symbol | :fill_me_in),
+      class_statements_return_the_value_of_their_last_expression_one: (::Integer | :fill_me_in),
+      self_while_inside_class_is_class_object_not_instance_one: (bool | :fill_me_in),
+      you_can_use_self_instead_of_an_explicit_reference_to_dog_one: (::Symbol | :fill_me_in),
+      heres_still_another_way_to_write_class_methods_one: (::Symbol | :fill_me_in),
+      heres_an_easy_way_to_call_class_methods_from_instance_methods_one: (::Symbol | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutClassMethodsTest
+  def test_objects_are_objects: -> void
+  def test_classes_are_classes: -> void
+  def test_classes_are_objects_too: -> void
+  def test_objects_have_methods: -> void
+  def test_classes_have_methods: -> void
+  def test_you_can_define_methods_on_individual_objects: -> void
+  def test_other_objects_are_not_affected_by_these_singleton_methods: -> void
+  def test_since_classes_are_objects_you_can_define_singleton_methods_on_them_too: -> void
+  def test_class_methods_are_independent_of_instance_methods: -> void
+  def test_classes_and_instances_do_not_share_instance_variables: -> void
+  def test_you_can_define_class_methods_inside_the_class: -> void
+  def test_class_statements_return_the_value_of_their_last_expression: -> void
+  def test_self_while_inside_class_is_class_object_not_instance: -> void
+  def test_you_can_use_self_instead_of_an_explicit_reference_to_dog: -> void
+  def test_heres_still_another_way_to_write_class_methods: -> void
+  def test_heres_an_easy_way_to_call_class_methods_from_instance_methods: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+end
+
+class AboutClassMethodsTest::Dog
+  attr_accessor name: ::String?
+  def self.name: () -> ::String?
+  def self.a_class_method: () -> ::Symbol
+  def self.class_method2: () -> ::Symbol
+  def self.another_class_method: () -> ::Symbol
+end
+
+class AboutClassMethodsTest::Dog2
+  def wag: () -> ::Symbol
+  def self.wag: () -> ::Symbol
+end

data/sig/exercises/about_classes.rbs

@@ -0,0 +1,88 @@
+# 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
+  class AboutClasses
+    type answers = {
+      instances_of_classes_can_be_created_with_new_one: (singleton(::AboutClassesTest::Dog) | :fill_me_in),
+      instance_variables_can_be_set_by_assigning_to_them_one: (::Array[untyped] | :fill_me_in),
+      instance_variables_can_be_set_by_assigning_to_them_two: (::Array[::Symbol] | :fill_me_in),
+      instance_variables_cannot_be_accessed_outside_the_class_one: (singleton(::NoMethodError) | :fill_me_in),
+      instance_variables_cannot_be_accessed_outside_the_class_two: (singleton(::SyntaxError) | :fill_me_in),
+      you_can_politely_ask_for_instance_variable_values_one: (::String | :fill_me_in),
+      you_can_rip_the_value_out_using_instance_eval_one: (::String | :fill_me_in),
+      you_can_rip_the_value_out_using_instance_eval_two: (::String | :fill_me_in),
+      you_can_create_accessor_methods_to_return_instance_variables_one: (::String | :fill_me_in),
+      attr_reader_will_automatically_define_an_accessor_one: (::String | :fill_me_in),
+      attr_accessor_will_automatically_define_both_read_and_write_accessors_one: (::String | :fill_me_in),
+      initialize_provides_initial_values_for_instance_variables_one: (::String | :fill_me_in),
+      args_to_new_must_match_initialize_one: (singleton(::ArgumentError) | :fill_me_in),
+      different_objects_have_different_instance_variables_one: (bool | :fill_me_in),
+      inside_a_method_self_refers_to_the_containing_object_one: (bool | :fill_me_in),
+      to_s_provides_a_string_version_of_the_object_one: (::String | :fill_me_in),
+      to_s_is_used_in_string_interpolation_one: (::String | :fill_me_in),
+      inspect_provides_a_more_complete_string_version_one: (::String | :fill_me_in),
+      all_objects_support_to_s_and_inspect_one: (::String | :fill_me_in),
+      all_objects_support_to_s_and_inspect_two: (::String | :fill_me_in),
+      all_objects_support_to_s_and_inspect_three: (::String | :fill_me_in),
+      all_objects_support_to_s_and_inspect_four: (::String | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutClassesTest
+  def test_instances_of_classes_can_be_created_with_new: -> void
+  def test_instance_variables_can_be_set_by_assigning_to_them: -> void
+  def test_instance_variables_cannot_be_accessed_outside_the_class: -> void
+  def test_you_can_politely_ask_for_instance_variable_values: -> void
+  def test_you_can_rip_the_value_out_using_instance_eval: -> void
+  def test_you_can_create_accessor_methods_to_return_instance_variables: -> void
+  def test_attr_reader_will_automatically_define_an_accessor: -> void
+  def test_attr_accessor_will_automatically_define_both_read_and_write_accessors: -> void
+  def test_initialize_provides_initial_values_for_instance_variables: -> void
+  def test_args_to_new_must_match_initialize: -> void
+  def test_different_objects_have_different_instance_variables: -> void
+  def test_inside_a_method_self_refers_to_the_containing_object: -> void
+  def test_to_s_provides_a_string_version_of_the_object: -> void
+  def test_to_s_is_used_in_string_interpolation: -> void
+  def test_inspect_provides_a_more_complete_string_version: -> void
+  def test_all_objects_support_to_s_and_inspect: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+end
+
+class AboutClassesTest::Dog
+
+end
+
+class AboutClassesTest::Dog2
+  def set_name: (::String a_name) -> ::String
+end
+
+class AboutClassesTest::Dog3
+  def set_name: (::String a_name) -> ::String
+  def name: () -> ::String?
+end
+
+class AboutClassesTest::Dog4
+  attr_reader name: ::String?
+  def set_name: (::String a_name) -> ::String
+end
+
+class AboutClassesTest::Dog5
+  attr_accessor name: ::String?
+end
+
+class AboutClassesTest::Dog6
+  attr_reader name: ::String?
+  def initialize: (::String initial_name) -> void
+end
+
+class AboutClassesTest::Dog7
+  attr_reader name: ::String?
+  def initialize: (::String initial_name) -> void
+  def get_self: () -> self
+  def to_s: () -> ::String
+  def inspect: () -> ::String
+end

data/sig/exercises/about_constants.rbs

@@ -0,0 +1,53 @@
+# 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
+  class AboutConstants
+    type answers = {
+      nested_constants_may_also_be_referenced_with_relative_paths_one: (::String | :fill_me_in),
+      top_level_constants_are_referenced_by_double_colons_one: (::String | :fill_me_in),
+      nested_constants_are_referenced_by_their_complete_path_one: (::String | :fill_me_in),
+      nested_constants_are_referenced_by_their_complete_path_two: (::String | :fill_me_in),
+      nested_classes_inherit_constants_from_enclosing_classes_one: (::Integer | :fill_me_in),
+      subclasses_inherit_constants_from_parent_classes_one: (::Integer | :fill_me_in),
+      who_wins_with_both_nested_and_inherited_constants_one: (::Integer | :fill_me_in),
+      who_wins_with_explicit_scoping_on_class_definition_one: (::Integer | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutConstantsTest
+  def test_nested_constants_may_also_be_referenced_with_relative_paths: -> void
+  def test_top_level_constants_are_referenced_by_double_colons: -> void
+  def test_nested_constants_are_referenced_by_their_complete_path: -> void
+  def test_nested_classes_inherit_constants_from_enclosing_classes: -> void
+  def test_subclasses_inherit_constants_from_parent_classes: -> void
+  def test_who_wins_with_both_nested_and_inherited_constants: -> void
+  def test_who_wins_with_explicit_scoping_on_class_definition: -> void
+end
+
+class AboutConstantsTest::Animal
+  def legs_in_animal: () -> ::Integer
+end
+
+class AboutConstantsTest::Animal::NestedAnimal
+  def legs_in_nested_animal: () -> ::Integer
+end
+
+class AboutConstantsTest::Reptile
+  def legs_in_reptile: () -> ::Integer
+end
+
+class AboutConstantsTest::MyAnimals
+
+end
+
+class AboutConstantsTest::MyAnimals::Bird
+  def legs_in_bird: () -> ::Integer
+end
+
+class AboutConstantsTest::MyAnimals::Oyster
+  def legs_in_oyster: () -> ::Integer
+end

data/sig/exercises/about_control_statements.rbs

@@ -0,0 +1,46 @@
+# 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
+  class AboutControlStatements
+    type answers = {
+      if_then_else_statements_one: (::Symbol | :fill_me_in),
+      if_then_statements_one: (::Symbol | :fill_me_in),
+      if_statements_return_values_one: (::Symbol | :fill_me_in),
+      if_statements_return_values_two: (::Symbol | :fill_me_in),
+      if_statements_with_no_else_with_false_condition_return_value_one: (nil | :fill_me_in),
+      condition_operators_one: (::Symbol | :fill_me_in),
+      condition_operators_two: (::Symbol | :fill_me_in),
+      if_statement_modifiers_one: (::Symbol | :fill_me_in),
+      unless_statement_one: (::Symbol | :fill_me_in),
+      unless_statement_evaluate_true_one: (::Symbol | :fill_me_in),
+      unless_statement_modifier_one: (::Symbol | :fill_me_in),
+      while_statement_one: (::Integer | :fill_me_in),
+      break_statement_one: (::Integer | :fill_me_in),
+      break_statement_returns_values_one: (::Integer | :fill_me_in),
+      next_statement_one: (::Array[::Integer] | :fill_me_in),
+      for_statement_one: (::Array[::String] | :fill_me_in),
+      times_statement_one: (::Integer | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutControlStatementsTest
+  def test_if_then_else_statements: -> void
+  def test_if_then_statements: -> void
+  def test_if_statements_return_values: -> void
+  def test_if_statements_with_no_else_with_false_condition_return_value: -> void
+  def test_condition_operators: -> void
+  def test_if_statement_modifiers: -> void
+  def test_unless_statement: -> void
+  def test_unless_statement_evaluate_true: -> void
+  def test_unless_statement_modifier: -> void
+  def test_while_statement: -> void
+  def test_break_statement: -> void
+  def test_break_statement_returns_values: -> void
+  def test_next_statement: -> void
+  def test_for_statement: -> void
+  def test_times_statement: -> void
+end

data/sig/exercises/about_dice_project.rbs

@@ -0,0 +1,16 @@
+module Exercises
+  class AboutDiceProject
+    class DiceSet
+      @random: Random
+      @values: Array[Integer]
+      attr_reader values: Array[Integer]
+      def initialize: (?random: Random) -> void
+      def roll: (Integer count) -> Array[Integer]
+    end
+  end
+end
+
+class AboutDiceProjectTest
+  def test_can_create_and_resize_a_dice_set: -> void
+  def test_rolls_use_the_random_source_and_values_stay_stable: -> void
+end

data/sig/exercises/about_exceptions.rbs

@@ -0,0 +1,36 @@
+# 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
+  class AboutExceptions
+    type answers = {
+      exceptions_inherit_from_Exception_one: (singleton(::RuntimeError) | :fill_me_in),
+      exceptions_inherit_from_Exception_two: (singleton(::StandardError) | :fill_me_in),
+      exceptions_inherit_from_Exception_three: (singleton(::Exception) | :fill_me_in),
+      exceptions_inherit_from_Exception_four: (singleton(::Object) | :fill_me_in),
+      rescue_clause_one: (::Symbol | :fill_me_in),
+      rescue_clause_two: (bool | :fill_me_in),
+      rescue_clause_three: (bool | :fill_me_in),
+      rescue_clause_four: (::String | :fill_me_in),
+      raising_a_particular_error_one: (::Symbol | :fill_me_in),
+      raising_a_particular_error_two: (::String | :fill_me_in),
+      ensure_clause_one: (::Symbol | :fill_me_in),
+      asserting_an_error_is_raised_one: (singleton(::AboutExceptionsTest::MySpecialError) | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutExceptionsTest
+  def test_exceptions_inherit_from_Exception: -> void
+  def test_rescue_clause: -> void
+  def test_raising_a_particular_error: -> void
+  def test_ensure_clause: -> void
+  def test_asserting_an_error_is_raised: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+end
+
+class AboutExceptionsTest::MySpecialError < ::RuntimeError
+
+end

data/sig/exercises/about_extra_credit.rbs

@@ -0,0 +1,36 @@
+module Exercises
+  class AboutExtraCredit
+    class Player
+      @name: String
+      @score: Integer
+      attr_reader name: String
+      attr_reader score: Integer
+      def initialize: (String name) -> void
+      def bank: (Integer points) -> Integer
+    end
+    class Game
+      @players: Array[Player]
+      @current: Integer
+      @remaining: Integer?
+      attr_reader players: Array[Player]
+      attr_reader current: Integer
+      def initialize: (Array[String] names) -> void
+      def play_turn: (Array[Array[Integer]] rolls) -> Integer
+      def finished?: -> bool
+      def winner: -> Player?
+      private
+      def turn_points: (Array[Array[Integer]] rolls) -> Integer
+      def validate_roll: (Array[Integer] roll, Integer count) -> void
+      def score_roll: (Array[Integer] roll) -> [Integer, Integer]
+      def advance: (Integer total) -> Integer
+    end
+  end
+end
+
+class AboutExtraCreditTest
+  def test_final_round_starts_at_3000_and_wraps_turn_order: -> void
+  def test_entry_threshold_and_later_banking: -> void
+  def test_bust_discards_the_entire_turn: -> void
+  def test_hot_dice_and_roll_validation: -> void
+  def test_every_other_player_gets_one_final_turn: -> void
+end

data/sig/exercises/about_hashes.rbs

@@ -0,0 +1,62 @@
+# 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
+  class AboutHashes
+    type answers = {
+      creating_hashes_one: (singleton(::Hash) | :fill_me_in),
+      creating_hashes_two: (::Hash[untyped, untyped] | :fill_me_in),
+      creating_hashes_three: (::Integer | :fill_me_in),
+      hash_literals_one: (::Integer | :fill_me_in),
+      accessing_hashes_one: (::String | :fill_me_in),
+      accessing_hashes_two: (::String | :fill_me_in),
+      accessing_hashes_three: (nil | :fill_me_in),
+      accessing_hashes_with_fetch_one: (::String | :fill_me_in),
+      accessing_hashes_with_fetch_two: (singleton(::KeyError) | :fill_me_in),
+      changing_hashes_one: (::Hash[::Symbol, ::String] | :fill_me_in),
+      hash_is_unordered_one: (bool | :fill_me_in),
+      hash_keys_one: (::Integer | :fill_me_in),
+      hash_keys_two: (bool | :fill_me_in),
+      hash_keys_three: (bool | :fill_me_in),
+      hash_keys_four: (singleton(::Array) | :fill_me_in),
+      hash_values_one: (::Integer | :fill_me_in),
+      hash_values_two: (bool | :fill_me_in),
+      hash_values_three: (bool | :fill_me_in),
+      hash_values_four: (singleton(::Array) | :fill_me_in),
+      combining_hashes_one: (bool | :fill_me_in),
+      combining_hashes_two: (bool | :fill_me_in),
+      default_value_one: (::Integer | :fill_me_in),
+      default_value_two: (nil | :fill_me_in),
+      default_value_three: (::Integer | :fill_me_in),
+      default_value_four: (::String | :fill_me_in),
+      default_value_is_the_same_object_one: (::Array[::String] | :fill_me_in),
+      default_value_is_the_same_object_two: (::Array[::String] | :fill_me_in),
+      default_value_is_the_same_object_three: (::Array[::String] | :fill_me_in),
+      default_value_is_the_same_object_four: (bool | :fill_me_in),
+      default_value_with_block_one: (::Array[::String] | :fill_me_in),
+      default_value_with_block_two: (::Array[::String] | :fill_me_in),
+      default_value_with_block_three: (::Array[untyped] | :fill_me_in),
+      default_value_attribute_one: (nil | :fill_me_in),
+      default_value_attribute_two: (::String | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutHashesTest
+  def test_creating_hashes: -> void
+  def test_hash_literals: -> void
+  def test_accessing_hashes: -> void
+  def test_accessing_hashes_with_fetch: -> void
+  def test_changing_hashes: -> void
+  def test_hash_is_unordered: -> void
+  def test_hash_keys: -> void
+  def test_hash_values: -> void
+  def test_combining_hashes: -> void
+  def test_default_value: -> void
+  def test_default_value_is_the_same_object: -> void
+  def test_default_value_with_block: -> void
+  def test_default_value_attribute: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+end

data/sig/exercises/about_inheritance.rbs

@@ -0,0 +1,50 @@
+# 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
+  class AboutInheritance
+    type answers = {
+      subclasses_have_the_parent_as_an_ancestor_one: (bool | :fill_me_in),
+      all_classes_ultimately_inherit_from_object_one: (bool | :fill_me_in),
+      subclasses_inherit_behavior_from_parent_class_one: (::String | :fill_me_in),
+      subclasses_add_new_behavior_one: (::Symbol | :fill_me_in),
+      subclasses_add_new_behavior_two: (singleton(::NoMethodError) | :fill_me_in),
+      subclasses_can_modify_existing_behavior_one: (::String | :fill_me_in),
+      subclasses_can_modify_existing_behavior_two: (::String | :fill_me_in),
+      subclasses_can_invoke_parent_behavior_via_super_one: (::String | :fill_me_in),
+      super_does_not_work_cross_method_one: (singleton(::NoMethodError) | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutInheritanceTest
+  def test_subclasses_have_the_parent_as_an_ancestor: -> void
+  def test_all_classes_ultimately_inherit_from_object: -> void
+  def test_subclasses_inherit_behavior_from_parent_class: -> void
+  def test_subclasses_add_new_behavior: -> void
+  def test_subclasses_can_modify_existing_behavior: -> void
+  def test_subclasses_can_invoke_parent_behavior_via_super: -> void
+  def test_super_does_not_work_cross_method: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+end
+
+class AboutInheritanceTest::Dog
+  attr_reader name: ::String?
+  def initialize: (::String name) -> void
+  def bark: () -> ::String
+end
+
+class AboutInheritanceTest::Chihuahua < ::AboutInheritanceTest::Dog
+  def wag: () -> ::Symbol
+  def bark: () -> ::String
+end
+
+class AboutInheritanceTest::BullDog < ::AboutInheritanceTest::Dog
+  def bark: () -> ::String
+end
+
+class AboutInheritanceTest::GreatDane < ::AboutInheritanceTest::Dog
+  def growl: () -> untyped
+end

data/sig/exercises/about_iteration.rbs

@@ -0,0 +1,37 @@
+# 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
+  class AboutIteration
+    type answers = {
+      each_is_a_method_on_arrays_one: (bool | :fill_me_in),
+      iterating_with_each_one: (::Integer | :fill_me_in),
+      each_can_use_curly_brace_blocks_too_one: (::Integer | :fill_me_in),
+      break_works_with_each_style_iterations_one: (::Integer | :fill_me_in),
+      collect_transforms_elements_of_an_array_one: (::Array[::Integer] | :fill_me_in),
+      collect_transforms_elements_of_an_array_two: (::Array[::Integer] | :fill_me_in),
+      select_selects_certain_items_from_an_array_one: (::Array[::Integer] | :fill_me_in),
+      select_selects_certain_items_from_an_array_two: (::Array[::Integer] | :fill_me_in),
+      find_locates_the_first_element_matching_a_criteria_one: (::String | :fill_me_in),
+      inject_will_blow_your_mind_one: (::Integer | :fill_me_in),
+      inject_will_blow_your_mind_two: (::Integer | :fill_me_in),
+      all_iteration_methods_work_on_any_collection_not_just_arrays_one: (::Array[::Integer] | :fill_me_in),
+      all_iteration_methods_work_on_any_collection_not_just_arrays_two: (::Array[::String] | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutIterationTest
+  def test_each_is_a_method_on_arrays: -> void
+  def test_iterating_with_each: -> void
+  def test_each_can_use_curly_brace_blocks_too: -> void
+  def test_break_works_with_each_style_iterations: -> void
+  def test_collect_transforms_elements_of_an_array: -> void
+  def test_select_selects_certain_items_from_an_array: -> void
+  def test_find_locates_the_first_element_matching_a_criteria: -> void
+  def test_inject_will_blow_your_mind: -> void
+  def test_all_iteration_methods_work_on_any_collection_not_just_arrays: -> void
+  def with_example_file: [A] () { (File) -> A } -> A
+end

data/sig/exercises/about_keyword_arguments.rbs

@@ -0,0 +1,33 @@
+# 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
+  class AboutKeywordArguments
+    type answers = {
+      keyword_arguments_one: (singleton(::Array) | :fill_me_in),
+      keyword_arguments_two: (::Array[::Integer | ::String] | :fill_me_in),
+      keyword_arguments_three: (::Array[::String] | :fill_me_in),
+      keyword_arguments_four: (::Array[::Integer] | :fill_me_in),
+      keyword_arguments_with_wrong_number_of_arguments_one: (singleton(::ArgumentError) | :fill_me_in),
+      keyword_arguments_with_wrong_number_of_arguments_two: (::String | :fill_me_in),
+      mandatory_keyword_arguments_one: (::Array[::String] | :fill_me_in),
+      mandatory_keyword_arguments_two: (::Array[::Integer] | :fill_me_in),
+      mandatory_keyword_arguments_without_mandatory_argument_one: (singleton(::ArgumentError) | :fill_me_in),
+      mandatory_keyword_arguments_without_mandatory_argument_two: (::String | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutKeywordArgumentsTest
+  def method_with_keyword_arguments: (?one: Integer | String, ?two: Integer | String) -> [Integer | String, Integer | String]
+  def test_keyword_arguments: -> void
+  def method_with_keyword_arguments_with_mandatory_argument: (untyped one, ?two: Integer, ?three: Integer) -> [untyped, Integer, Integer]
+  def test_keyword_arguments_with_wrong_number_of_arguments: -> void
+  def method_with_mandatory_keyword_arguments: (one: Integer | String, ?two: Integer | String) -> [Integer | String, Integer | String]
+  def test_mandatory_keyword_arguments: -> void
+  def test_mandatory_keyword_arguments_without_mandatory_argument: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+  def assert_predicted_message: (::Symbol key, ::String message) -> void
+end

data/sig/exercises/about_message_passing.rbs

@@ -0,0 +1,68 @@
+# 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
+  class AboutMessagePassing
+    type answers = {
+      methods_can_be_invoked_more_dynamically_one: (bool | :fill_me_in),
+      methods_can_be_invoked_more_dynamically_two: (bool | :fill_me_in),
+      send_with_underscores_will_also_send_messages_one: (bool | :fill_me_in),
+      classes_can_be_asked_if_they_know_how_to_respond_one: (bool | :fill_me_in),
+      classes_can_be_asked_if_they_know_how_to_respond_two: (bool | :fill_me_in),
+      sending_a_message_with_arguments_one: (::Array[untyped] | :fill_me_in),
+      sending_a_message_with_arguments_two: (::Array[untyped] | :fill_me_in),
+      sending_a_message_with_arguments_three: (::Array[::Integer | nil] | :fill_me_in),
+      sending_a_message_with_arguments_four: (::Array[::Integer | nil] | :fill_me_in),
+      sending_undefined_messages_to_a_typical_object_results_in_errors_one: (singleton(::NoMethodError) | :fill_me_in),
+      calling_method_missing_causes_the_no_method_error_one: (singleton(::NoMethodError) | :fill_me_in),
+      all_messages_are_caught_one: (::String | :fill_me_in),
+      all_messages_are_caught_two: (::String | :fill_me_in),
+      all_messages_are_caught_three: (::String | :fill_me_in),
+      catching_messages_makes_respond_to_lie_one: (bool | :fill_me_in),
+      foo_method_are_caught_one: (::String | :fill_me_in),
+      foo_method_are_caught_two: (::String | :fill_me_in),
+      non_foo_messages_are_treated_normally_one: (singleton(::NoMethodError) | :fill_me_in),
+      explicitly_implementing_respond_to_lets_objects_tell_the_truth_one: (bool | :fill_me_in),
+      explicitly_implementing_respond_to_lets_objects_tell_the_truth_two: (bool | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutMessagePassingTest
+  def test_methods_can_be_called_directly: -> void
+  def test_methods_can_be_invoked_by_sending_the_message: -> void
+  def test_methods_can_be_invoked_more_dynamically: -> void
+  def test_send_with_underscores_will_also_send_messages: -> void
+  def test_classes_can_be_asked_if_they_know_how_to_respond: -> void
+  def test_sending_a_message_with_arguments: -> void
+  def test_sending_undefined_messages_to_a_typical_object_results_in_errors: -> void
+  def test_calling_method_missing_causes_the_no_method_error: -> void
+  def test_all_messages_are_caught: -> void
+  def test_catching_messages_makes_respond_to_lie: -> void
+  def test_foo_method_are_caught: -> void
+  def test_non_foo_messages_are_treated_normally: -> void
+  def test_explicitly_implementing_respond_to_lets_objects_tell_the_truth: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+end
+
+class AboutMessagePassingTest::MessageCatcher
+  def caught?: () -> bool
+  def add_a_payload: [A] (*A args) -> Array[A]
+end
+
+class AboutMessagePassingTest::TypicalObject
+
+end
+
+class AboutMessagePassingTest::AllMessageCatcher
+  def method_missing: (Symbol method_name, *untyped args) ?{ (*untyped) -> untyped } -> String
+end
+
+class AboutMessagePassingTest::WellBehavedFooCatcher
+  def method_missing: (Symbol method_name, *untyped args) ?{ (*untyped) -> untyped } -> String
+  private
+  def respond_to_missing?: (Symbol | String method_name, ?bool include_private) -> bool
+  public
+end

data/sig/exercises/about_methods.rbs

@@ -0,0 +1,68 @@
+# 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
+  class AboutMethods
+    type answers = {
+      calling_global_methods_one: (::Integer | :fill_me_in),
+      calling_global_methods_without_parentheses_one: (::Integer | :fill_me_in),
+      sometimes_missing_parentheses_are_ambiguous_one: (::Integer | :fill_me_in),
+      calling_global_methods_with_wrong_number_of_arguments_one: (singleton(::ArgumentError) | :fill_me_in),
+      calling_global_methods_with_wrong_number_of_arguments_two: (::String | :fill_me_in),
+      calling_global_methods_with_wrong_number_of_arguments_three: (singleton(::ArgumentError) | :fill_me_in),
+      calling_global_methods_with_wrong_number_of_arguments_four: (::String | :fill_me_in),
+      calling_with_default_values_one: (::Array[::Integer | ::Symbol] | :fill_me_in),
+      calling_with_default_values_two: (::Array[::Integer] | :fill_me_in),
+      calling_with_variable_arguments_one: (singleton(::Array) | :fill_me_in),
+      calling_with_variable_arguments_two: (::Array[untyped] | :fill_me_in),
+      calling_with_variable_arguments_three: (::Array[::Symbol] | :fill_me_in),
+      calling_with_variable_arguments_four: (::Array[::Symbol] | :fill_me_in),
+      method_with_explicit_return_one: (::Symbol | :fill_me_in),
+      method_without_explicit_return_one: (::Symbol | :fill_me_in),
+      calling_methods_in_same_class_one: (::Integer | :fill_me_in),
+      calling_methods_in_same_class_with_explicit_receiver_one: (::Integer | :fill_me_in),
+      calling_private_methods_without_receiver_one: (::String | :fill_me_in),
+      calling_private_methods_with_an_explicit_receiver_one: (::String | :fill_me_in),
+      calling_methods_in_other_objects_require_explicit_receiver_one: (::String | :fill_me_in),
+      calling_private_methods_in_other_objects_one: (singleton(::NoMethodError) | :fill_me_in)
+    }
+    def self.koans: -> answers
+  end
+end
+
+class AboutMethodsTest
+  def test_calling_global_methods: -> void
+  def test_calling_global_methods_without_parentheses: -> void
+  def test_sometimes_missing_parentheses_are_ambiguous: -> void
+  def test_calling_global_methods_with_wrong_number_of_arguments: -> void
+  def method_with_defaults: [A, B] (A a, ?B b) -> [A, B | Symbol]
+  def test_calling_with_default_values: -> void
+  def method_with_var_args: [A] (*A args) -> Array[A]
+  def test_calling_with_variable_arguments: -> void
+  def method_with_explicit_return: -> Symbol
+  def test_method_with_explicit_return: -> void
+  def method_without_explicit_return: -> Symbol
+  def test_method_without_explicit_return: -> void
+  def my_method_in_the_same_class: (Integer a, Integer b) -> Integer
+  def test_calling_methods_in_same_class: -> void
+  def test_calling_methods_in_same_class_with_explicit_receiver: -> void
+  private
+  def my_private_method: -> String
+  public
+  def test_calling_private_methods_without_receiver: -> void
+  def test_calling_private_methods_with_an_explicit_receiver: -> void
+  def test_calling_methods_in_other_objects_require_explicit_receiver: -> void
+  def test_calling_private_methods_in_other_objects: -> void
+  def assert_predicted_error: (::Symbol key, singleton(::Exception) klass) { () -> untyped } -> ::Exception
+  def assert_predicted_message: (::Symbol key, ::String message) -> void
+end
+
+class AboutMethodsTest::Dog
+  def name: () -> ::String?
+  def tail: () -> ::String
+end
+
+class Object
+  def my_global_method: (Integer a, Integer b) -> Integer
+end