rkoans 0.0.1 → 0.1.0

data/exercises/about-regular-expressions/about_regular_expressions.rb

@@ -0,0 +1,174 @@
+# 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 regular expressions examples.
+  class AboutRegularExpressions
+    # 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
+      {
+        # A pattern is a regular expression.
+        # assert_equal __, /pattern/.class
+        # Predict: /pattern/.class
+        a_pattern_is_a_regular_expression_one: :fill_me_in,
+        # A regexp can search a string for matching content.
+        # assert_equal __, "some matching content"[/match/]
+        # Predict: "some matching content"[/match/]
+        a_regexp_can_search_a_string_for_matching_content_one: :fill_me_in,
+        # A failed match returns nil.
+        # assert_equal __, "some matching content"[/missing/]
+        # Predict: "some matching content"[/missing/]
+        a_failed_match_returns_nil_one: :fill_me_in,
+        # Question mark means optional.
+        # assert_equal __, "abbcccddddeeeee"[/ab?/]
+        # assert_equal __, "abbcccddddeeeee"[/az?/]
+        # Predict: "abbcccddddeeeee"[/ab?/]
+        question_mark_means_optional_one: :fill_me_in,
+        # Predict: "abbcccddddeeeee"[/az?/]
+        question_mark_means_optional_two: :fill_me_in,
+        # Plus means one or more.
+        # assert_equal __, "abbcccddddeeeee"[/bc+/]
+        # Predict: "abbcccddddeeeee"[/bc+/]
+        plus_means_one_or_more_one: :fill_me_in,
+        # Asterisk means zero or more.
+        # assert_equal __, "abbcccddddeeeee"[/ab*/]
+        # assert_equal __, "abbcccddddeeeee"[/az*/]
+        # assert_equal __, "abbcccddddeeeee"[/z*/]
+        # Predict: "abbcccddddeeeee"[/ab*/]
+        asterisk_means_zero_or_more_one: :fill_me_in,
+        # Predict: "abbcccddddeeeee"[/az*/]
+        asterisk_means_zero_or_more_two: :fill_me_in,
+        # Predict: "abbcccddddeeeee"[/z*/]
+        asterisk_means_zero_or_more_three: :fill_me_in,
+        # The left most match wins.
+        # assert_equal __, "abbccc az"[/az*/]
+        # Predict: "abbccc az"[/az*/]
+        the_left_most_match_wins_one: :fill_me_in,
+        # Character classes give options for a character.
+        # animals = ["cat", "bat", "rat", "zat"]
+        # assert_equal __, animals.select { |a| a[/[cbr]at/] }
+        # Predict: animals.select { |a| a[/[cbr]at/] }
+        character_classes_give_options_for_a_character_one: :fill_me_in,
+        # Slash d is a shortcut for a digit character class.
+        # assert_equal __, "the number is 42"[/[0123456789]+/]
+        # assert_equal __, "the number is 42"[/\d+/]
+        # Predict: "the number is 42"[/[0123456789]+/]
+        slash_d_is_a_shortcut_for_a_digit_character_class_one: :fill_me_in,
+        # Predict: "the number is 42"[/\d+/]
+        slash_d_is_a_shortcut_for_a_digit_character_class_two: :fill_me_in,
+        # Character classes can include ranges.
+        # assert_equal __, "the number is 42"[/[0-9]+/]
+        # Predict: "the number is 42"[/[0-9]+/]
+        character_classes_can_include_ranges_one: :fill_me_in,
+        # Slash s is a shortcut for a whitespace character class.
+        # assert_equal __, "space: \t\n"[/\s+/]
+        # Predict: "space: \t\n"[/\s+/]
+        slash_s_is_a_shortcut_for_a_whitespace_character_class_one: :fill_me_in,
+        # Slash w is a shortcut for a word character class.
+        # assert_equal __, "variable_1 = 42"[/[a-zA-Z0-9_]+/]
+        # assert_equal __, "variable_1 = 42"[/\w+/]
+        # Predict: "variable_1 = 42"[/[a-zA-Z0-9_]+/]
+        slash_w_is_a_shortcut_for_a_word_character_class_one: :fill_me_in,
+        # Predict: "variable_1 = 42"[/\w+/]
+        slash_w_is_a_shortcut_for_a_word_character_class_two: :fill_me_in,
+        # Period is a shortcut for any non newline character.
+        # assert_equal __, "abc\n123"[/a.+/]
+        # Predict: "abc\n123"[/a.+/]
+        period_is_a_shortcut_for_any_non_newline_character_one: :fill_me_in,
+        # A character class can be negated.
+        # assert_equal __, "the number is 42"[/[^0-9]+/]
+        # Predict: "the number is 42"[/[^0-9]+/]
+        a_character_class_can_be_negated_one: :fill_me_in,
+        # Shortcut character classes are negated with capitals.
+        # assert_equal __, "the number is 42"[/\D+/]
+        # assert_equal __, "space: \t\n"[/\S+/]
+        # ... a programmer would most likely do
+        # assert_equal __, "variable_1 = 42"[/[^a-zA-Z0-9_]+/]
+        # assert_equal __, "variable_1 = 42"[/\W+/]
+        # Predict: "the number is 42"[/\D+/]
+        shortcut_character_classes_are_negated_with_capitals_one: :fill_me_in,
+        # Predict: "space: \t\n"[/\S+/]
+        shortcut_character_classes_are_negated_with_capitals_two: :fill_me_in,
+        # Predict: "variable_1 = 42"[/[^a-zA-Z0-9_]+/]
+        shortcut_character_classes_are_negated_with_capitals_three: :fill_me_in,
+        # Predict: "variable_1 = 42"[/\W+/]
+        shortcut_character_classes_are_negated_with_capitals_four: :fill_me_in,
+        # Slash a anchors to the start of the string.
+        # assert_equal __, "start end"[/\Astart/]
+        # assert_equal __, "start end"[/\Aend/]
+        # Predict: "start end"[/\Astart/]
+        slash_a_anchors_to_the_start_of_the_string_one: :fill_me_in,
+        # Predict: "start end"[/\Aend/]
+        slash_a_anchors_to_the_start_of_the_string_two: :fill_me_in,
+        # Slash z anchors to the end of the string.
+        # assert_equal __, "start end"[/end\z/]
+        # assert_equal __, "start end"[/start\z/]
+        # Predict: "start end"[/end\z/]
+        slash_z_anchors_to_the_end_of_the_string_one: :fill_me_in,
+        # Predict: "start end"[/start\z/]
+        slash_z_anchors_to_the_end_of_the_string_two: :fill_me_in,
+        # Caret anchors to the start of lines.
+        # assert_equal __, "num 42\n2 lines"[/^\d+/]
+        # Predict: "num 42\n2 lines"[/^\d+/]
+        caret_anchors_to_the_start_of_lines_one: :fill_me_in,
+        # Dollar sign anchors to the end of lines.
+        # assert_equal __, "2 lines\nnum 42"[/\d+$/]
+        # Predict: "2 lines\nnum 42"[/\d+$/]
+        dollar_sign_anchors_to_the_end_of_lines_one: :fill_me_in,
+        # Slash b anchors to a word boundary.
+        # assert_equal __, "bovine vines"[/\bvine./]
+        # Predict: "bovine vines"[/\bvine./]
+        slash_b_anchors_to_a_word_boundary_one: :fill_me_in,
+        # Parentheses group contents.
+        # assert_equal __, "ahahaha"[/(ha)+/]
+        # Predict: "ahahaha"[/(ha)+/]
+        parentheses_group_contents_one: :fill_me_in,
+        # Parentheses also capture matched content by number.
+        # assert_equal __, "Gray, James"[/(\w+), (\w+)/, 1]
+        # assert_equal __, "Gray, James"[/(\w+), (\w+)/, 2]
+        # Predict: "Gray, James"[/(\w+), (\w+)/, 1]
+        parentheses_also_capture_matched_content_by_number_one: :fill_me_in,
+        # Predict: "Gray, James"[/(\w+), (\w+)/, 2]
+        parentheses_also_capture_matched_content_by_number_two: :fill_me_in,
+        # Variables can also be used to access captures.
+        # assert_equal __, "Name:  Gray, James"[/(\w+), (\w+)/]
+        # assert_equal __, $1
+        # assert_equal __, $2
+        # Predict: "Name:  Gray, James"[/(\w+), (\w+)/]
+        variables_can_also_be_used_to_access_captures_one: :fill_me_in,
+        # Predict: $1
+        variables_can_also_be_used_to_access_captures_two: :fill_me_in,
+        # Predict: $2
+        variables_can_also_be_used_to_access_captures_three: :fill_me_in,
+        # A vertical pipe means or.
+        # grays = /(James|Dana|Summer) Gray/
+        # assert_equal __, "James Gray"[grays]
+        # assert_equal __, "Summer Gray"[grays, 1]
+        # assert_equal __, "Jim Gray"[grays, 1]
+        # Predict: "James Gray"[grays]
+        a_vertical_pipe_means_or_one: :fill_me_in,
+        # Predict: "Summer Gray"[grays, 1]
+        a_vertical_pipe_means_or_two: :fill_me_in,
+        # Predict: "Jim Gray"[grays, 1]
+        a_vertical_pipe_means_or_three: :fill_me_in,
+        # Scan is like find all.
+        # assert_equal __, "one two-three".scan(/\w+/)
+        # Predict: "one two-three".scan(/\w+/)
+        scan_is_like_find_all_one: :fill_me_in,
+        # Sub is like find and replace.
+        # assert_equal __, "one two-three".sub(/(t\w*)/) { $1[0, 1] }
+        # Predict: "one two-three".sub(/(t\w*)/) { $1[0, 1] }
+        sub_is_like_find_and_replace_one: :fill_me_in,
+        # Gsub is like find and replace all.
+        # assert_equal __, "one two-three".gsub(/(t\w*)/) { $1[0, 1] }
+        # Predict: "one two-three".gsub(/(t\w*)/) { $1[0, 1] }
+        gsub_is_like_find_and_replace_all_one: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-regular-expressions/brief.md

@@ -0,0 +1,9 @@
+# About Regular Expressions
+
+Replace each `:fill_me_in` in `about_regular_expressions.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-regular-expressions/hint.md

@@ -0,0 +1,8 @@
+# Hint
+
+Try each pattern on the exact string in the example. Distinguish an empty
+match from no match, and whole-string anchors from line anchors. Captures retain
+the text matched by parenthesized groups.
+
+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-sandwich-code/about_sandwich_code.rb

@@ -0,0 +1,58 @@
+# 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.
+
+# Explicit open/ensure is the resource-cleanup pattern taught by this lesson.
+# rubocop:disable Style/FileOpen
+
+module Exercises
+  # Shares file acquisition and cleanup around different operations.
+  class AboutSandwichCode
+    # @return [Integer] number of lines, including a final line without a newline
+    def self.count_lines(path)
+      file = File.open(path)
+      count = 0
+      count += 1 while file.gets
+      count
+    ensure
+      file&.close
+    end
+
+    # @return [String, nil] first line containing e, preserving its line ending
+    def self.find_line(path)
+      file = File.open(path)
+      while (line = file.gets)
+        return line if line.include?('e')
+      end
+      nil
+    ensure
+      file&.close
+    end
+
+    # Yield an open file and close it on normal return, early exit or exception.
+    # @return [Object] the block's result
+    def self.file_sandwich(path)
+      file = File.open(path)
+      yield file
+    end
+
+    # @return [Integer] number of lines using the shared sandwich
+    def self.count_lines2(path)
+      file_sandwich(path) { |file| file.each_line.count }
+    end
+
+    # @return [String, nil] first matching line using the shared sandwich
+    def self.find_line2(_path)
+      nil
+    end
+
+    # @return [Integer] number of lines using File.open's built-in sandwich
+    def self.count_lines3(path)
+      File.open(path) { |file| file.each_line.count }
+    end
+  end
+end
+
+# rubocop:enable Style/FileOpen

data/exercises/about-sandwich-code/brief.md

@@ -0,0 +1,14 @@
+# Sandwich Code
+
+Complete `file_sandwich(path)` and `find_line2(path)` in `about_sandwich_code.rb`.
+The sandwich opens a file, yields it, returns the block's result, and always
+closes the file, even when the block raises or exits early. The second search
+method must use the sandwich to return the first line containing `e`, or `nil`
+when none matches. Keep the line ending when present.
+
+Compare the supplied counting and searching methods: explicit `ensure`, a shared
+block helper, and `File.open` with a block all provide resource cleanup. The
+original example has four lines: `this`, `is`, `a`, `test`. Checks create real
+temporary files, so the lesson works from any working directory.
+
+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-sandwich-code/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Put cleanup in ensure. Enumerable#find returns the first matching line or nil.
+
+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-scope/about_scope.rb

@@ -0,0 +1,76 @@
+# 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 scope examples.
+  class AboutScope
+    # 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
+      {
+        # Dog is not available in the current scope.
+        # assert_raise(___) do
+        # Dog.new
+        # end
+        # Predict: exception class from: Dog.new
+        dog_is_not_available_in_the_current_scope_one: :fill_me_in,
+        # You can reference nested classes using the scope operator.
+        # fido = Jims::Dog.new
+        # rover = Joes::Dog.new
+        # assert_equal __, fido.identify
+        # assert_equal __, rover.identify
+        # assert_equal __, fido.class != rover.class
+        # assert_equal __, Jims::Dog != Joes::Dog
+        # Predict: fido.identify
+        you_can_reference_nested_classes_using_the_scope_operator_one: :fill_me_in,
+        # Predict: rover.identify
+        you_can_reference_nested_classes_using_the_scope_operator_two: :fill_me_in,
+        # Predict: fido.class != rover.class
+        you_can_reference_nested_classes_using_the_scope_operator_three: :fill_me_in,
+        # Predict: Jims::Dog != Joes::Dog
+        you_can_reference_nested_classes_using_the_scope_operator_four: :fill_me_in,
+        # Bare bones class names assume the current scope.
+        # assert_equal __, AboutScopeTest::String == String
+        # Predict: AboutScopeTest::String == String
+        bare_bones_class_names_assume_the_current_scope_one: :fill_me_in,
+        # Nested string is not the same as the system string.
+        # assert_equal __, String == "HI".class
+        # Predict: String == "HI".class
+        nested_string_is_not_the_same_as_the_system_string_one: :fill_me_in,
+        # Use the prefix scope operator to force the global scope.
+        # assert_equal __, ::String == "HI".class
+        # Predict: ::String == "HI".class
+        use_the_prefix_scope_operator_to_force_the_global_scope_one: :fill_me_in,
+        # Constants are defined with an initial uppercase letter.
+        # assert_equal __, PI
+        # Predict: PI
+        constants_are_defined_with_an_initial_uppercase_letter_one: :fill_me_in,
+        # Class names are just constants.
+        # assert_equal __, MyString == ::String
+        # assert_equal __, MyString == "HI".class
+        # Predict: MyString == ::String
+        class_names_are_just_constants_one: :fill_me_in,
+        # Predict: MyString == "HI".class
+        class_names_are_just_constants_two: :fill_me_in,
+        # Constants can be looked up explicitly.
+        # assert_equal __, PI == AboutScopeTest.const_get("PI")
+        # assert_equal __, MyString == AboutScopeTest.const_get("MyString")
+        # Predict: PI == AboutScopeTest.const_get("PI")
+        constants_can_be_looked_up_explicitly_one: :fill_me_in,
+        # Predict: MyString == AboutScopeTest.const_get("MyString")
+        constants_can_be_looked_up_explicitly_two: :fill_me_in,
+        # You can get a list of constants for any class or module.
+        # assert_equal __, Jims.constants
+        # assert_equal __, Object.constants.any?
+        # Predict: Jims.constants
+        you_can_get_a_list_of_constants_for_any_class_or_module_one: :fill_me_in,
+        # Predict: Object.constants.any?
+        you_can_get_a_list_of_constants_for_any_class_or_module_two: :fill_me_in
+      }
+    end
+  end
+end

data/exercises/about-scope/brief.md

@@ -0,0 +1,35 @@
+# About Scope
+
+Replace each `:fill_me_in` in `about_scope.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 `AboutScopeTest`.
+
+```ruby
+module Jims
+    class Dog
+      def identify
+        :jims_dog
+      end
+    end
+  end
+
+module Joes
+    class Dog
+      def identify
+        :joes_dog
+      end
+    end
+  end
+
+class String
+  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-scope/hint.md

@@ -0,0 +1,8 @@
+# Hint
+
+A short constant name is resolved in its surrounding scope. `::` can start
+from the top level. Two nested classes with the same short name can be different
+class 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-scoring-project/about_scoring_project.rb

@@ -0,0 +1,16 @@
+# 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
+  # Scores a single Greed roll of up to five six-sided dice.
+  class AboutScoringProject
+    # @param dice [Array<Integer>] face values between one and six
+    # @return [Integer] points, counting each die only once
+    def self.score(_dice)
+      0
+    end
+  end
+end

data/exercises/about-scoring-project/brief.md

@@ -0,0 +1,10 @@
+# Scoring Project
+
+Implement `Exercises::AboutScoringProject.score(dice)` in `about_scoring_project.rb`.
+Score a roll of zero to five dice: three ones earn 1000, other triples earn
+100 times their face; leftover ones earn 100 and leftover fives earn 50.
+Other dice earn zero. Each die counts once. Return zero for an empty roll.
+
+Examples: `[1, 1, 1, 5, 1]` earns 1150; `[3, 4, 5, 3, 3]` earns 350.
+
+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-scoring-project/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Count each face, separate triples from remaining dice, then score the remainder.
+
+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-strings/about_strings.rb

@@ -0,0 +1,142 @@
+# 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 the results of quoting, interpolation, mutation, and string operations.
+  class AboutStrings
+    # Replace each nil with the result of its commented example.
+    # @return [Hash<Symbol, String | Integer | Boolean | Array<String> | nil>]
+    # The answer table is data, not a sequence of operations.
+    def self.koans # rubocop:disable Metrics/MethodLength
+      {
+        # double quoted strings are strings
+        # string = "Hello, World"
+        double_quoted_string: nil, # string.is_a?(String)
+        # single quoted strings are also strings
+        # string = 'Goodbye, World'
+        single_quoted_string: nil, # string.is_a?(String)
+        # use single quotes to create string with double quotes
+        # string = 'He said, "Go Away."'
+        quoted_speech: nil, # string
+        # use double quotes to create strings with single quotes
+        # string = "Don't"
+        apostrophe: nil, # string
+        # use backslash for those hard cases
+        # a = "He said, \"Don't\""
+        # b = 'He said, "Don\'t"'
+        escaped_quotes_equal: nil, # a == b
+        # use flexible quoting to handle really hard cases
+        # a = %(flexible quotes can handle both ' and " characters)
+        # b = %!flexible quotes can handle both ' and " characters!
+        # c = %{flexible quotes can handle both ' and " characters}
+        flexible_percent_equal: nil, # a == b
+        flexible_braces_equal: nil, # a == c
+        # flexible quotes can handle multiple lines
+        # long_string = %{
+        # It was the best of times,
+        # It was the worst of times.
+        # }
+        multiline_length: nil, # long_string.length
+        multiline_lines: nil, # long_string.lines.count
+        multiline_first_character: nil, # long_string[0,1]
+        # here documents can also handle multiple lines
+        # long_string = <<~EOS
+        #   It was the best of times,
+        #   It was the worst of times.
+        # EOS
+        heredoc_length: nil, # long_string.length
+        heredoc_lines: nil, # long_string.lines.count
+        heredoc_first_character: nil, # long_string[0,1]
+        # plus will concatenate two strings
+        # string = "Hello, " + "World"
+        concatenated: nil, # string
+        # plus concatenation will leave the original strings unmodified
+        # hi = "Hello, "
+        # there = "World"
+        # string = hi + there
+        plus_original: nil, # hi
+        plus_other: nil, # there
+        # plus equals will concatenate to the end of a string
+        # hi = "Hello, "
+        # there = "World"
+        # hi += there
+        plus_equals_result: nil, # hi
+        # plus equals also will leave the original string unmodified
+        # original_string = "Hello, "
+        # hi = original_string
+        # there = "World"
+        # hi += there
+        plus_equals_original: nil, # original_string
+        # the shovel operator will also append content to a string
+        # hi = "Hello, "
+        # there = "World"
+        # hi << there
+        append_result: nil, # hi
+        append_other: nil, # there
+        # the shovel operator modifies the original string
+        # original_string = "Hello, "
+        # hi = original_string
+        # there = "World"
+        # hi << there
+        # THINK ABOUT IT:
+        #
+        # Ruby programmers tend to favor the shovel operator (<<) over the
+        # plus equals operator (+=) when building up strings.  Why?
+        appended_original: nil, # original_string
+        # double quoted string interpret escape characters
+        # string = "\n"
+        double_escape_length: nil, # string.size
+        # single quoted string do not interpret escape characters
+        # string = '\n'
+        single_escape_length: nil, # string.size
+        # single quotes sometimes interpret escape characters
+        # string = '\\\''
+        quote_escape_length: nil, # string.size
+        quote_escape_text: nil, # string
+        # double quoted strings interpolate variables
+        # value = 123
+        # string = "The value is #{value}"
+        interpolated: nil, # string
+        # single quoted strings do not interpolate
+        # value = 123
+        # string = 'The value is #{value}'
+        not_interpolated: nil, # string
+        # any ruby expression may be interpolated
+        # string = "The square root of 5 is #{Math.sqrt(5)}"
+        math_interpolation: nil, # string
+        # you can get a substring from a string
+        # string = "Bacon, lettuce and tomato"
+        substring_slice: nil, # string[7,3]
+        substring_range: nil, # string[7..9]
+        # you can get a single character from a string
+        # string = "Bacon, lettuce and tomato"
+        # Surprised?
+        single_character: nil, # string[1]
+        # in modern ruby single characters are represented by strings
+        character_literal: nil, # ?a
+        character_equals_integer: nil, # ?a == 97
+        # strings can be split
+        # string = "Sausage Egg Cheese"
+        # words = string.split
+        split_words: nil, # words
+        # strings can be split with different patterns
+        # string = "the:rain:in:spain"
+        # words = string.split(/:/)
+        # NOTE: Patterns are formed from Regular Expressions.  Ruby has a
+        # powerful Regular Expression library.
+        pattern_words: nil, # words
+        # strings can be joined
+        # words = ["Now", "is", "the", "time"]
+        joined_words: nil, # words.join(" ")
+        # strings are unique objects
+        # a = "a string"
+        # b = "a string"
+        equal_strings: nil, # a           == b
+        same_object: nil # a.object_id == b.object_id
+      }
+    end
+  end
+end

data/exercises/about-strings/brief.md

@@ -0,0 +1,22 @@
+# Strings: quotes, changes, and identity
+
+Replace each `nil` in `koans` with the result predicted by the example above it.
+Use strings for text, integers for lengths and counts, `true` or `false` for
+comparisons, and arrays of strings for split results. Examples are comments so
+you can read and experiment with them without changing the checks.
+
+Work through quoting and multiline text, then concatenation and mutation, and
+finally escapes, interpolation, slicing, splitting, joining, and object identity.
+Both kinds of quotes make strings, but they handle escapes and interpolation
+differently. Compare `+`, `+=`, and `<<`: which operations change an existing
+string, and which give the variable another string?
+
+The checks use mutable string literals to make those experiments explicit.
+String equality and object identity are different questions. Character literals
+such as `?a` are strings on the Ruby version used here.
+
+Save a group of predictions at a time and compare Expected (your prediction)
+with Actual (Ruby's result).
+
+Adapted from **Ruby Koans: About Strings** by Jim Weirich and Joe O'Brien.
+Licensed under [CC BY-NC-SA 3.0](https://creativecommons.org/licenses/by-nc-sa/3.0/).

data/exercises/about-strings/hint.md

@@ -0,0 +1,11 @@
+# Hint: follow the object, not just the variable
+
+`+` creates a string; `+=` reassigns the variable to a concatenated string.
+`<<` appends to the existing string, so another variable referring to it sees
+the change. For identity, ask whether two names refer to the same object.
+
+Read escape and interpolation examples one character at a time. Multiline text
+includes its newline characters; single quotes preserve most backslashes.
+
+Adapted from **Ruby Koans: About Strings** by Jim Weirich and Joe O'Brien.
+Licensed under [CC BY-NC-SA 3.0](https://creativecommons.org/licenses/by-nc-sa/3.0/).

data/exercises/about-symbols/about_symbols.rb

@@ -0,0 +1,53 @@
+# 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 symbol identity, conversions, registered names, and supported operations.
+  class AboutSymbols
+    # Replace each :fill_me_in with the result of its example.
+    # @return [Hash<Symbol, Boolean | Symbol | String | Class>]
+    def self.koans
+      {
+        # :ruby.is_a?(Symbol)
+        symbol_type: :fill_me_in,
+        # :a_symbol == :a_symbol
+        same_value: :fill_me_in,
+        # :a_symbol == :something_else
+        different_value: :fill_me_in,
+        # :a_symbol == :a_symbol
+        identical_value: :fill_me_in,
+        # :a_symbol.equal?(:a_symbol)
+        same_object: :fill_me_in,
+        # Symbol.all_symbols.map(&:to_s).include?('test_method_names_become_symbols')
+        method_name_registered: :fill_me_in,
+        # name of the constant declared by the check class
+        constant_name: :fill_me_in,
+        # Symbol.all_symbols.map(&:to_s).include?('RUBY_CONSTANT')
+        constant_registered: :fill_me_in,
+        # 'catsAndDogs'.to_sym
+        from_string: :fill_me_in,
+        # :'cats and dogs'
+        with_spaces: :fill_me_in,
+        # value = 'and'; :"cats #{value} dogs"
+        with_interpolation: :fill_me_in,
+        # symbol = :cats; "It is raining #{symbol} and dogs."
+        interpolated_text: :fill_me_in,
+        # :ruby.is_a?(String)
+        string_type: :fill_me_in,
+        # :ruby.eql?('ruby')
+        equals_string: :fill_me_in,
+        # :not_a_string.respond_to?(:each_char)
+        each_char: :fill_me_in,
+        # :not_a_string.respond_to?(:reverse)
+        reverse: :fill_me_in,
+        # exception class raised by :cats + :dogs
+        concatenation_error: :fill_me_in,
+        # ('cats' + 'dogs').to_sym
+        dynamically_created: :fill_me_in
+      }
+    end
+  end
+end