rkoans 0.0.1 → 0.1.0

data/test/exercises/about_open_classes_test.rb

@@ -0,0 +1,60 @@
+# 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.
+
+require ARGV.shift
+class AboutOpenClassesTest < Minitest::Test
+  class Dog
+    # Demonstrates bark.
+    def bark
+      'WOOF'
+    end
+  end
+
+  # Checks as defined dogs do bark.
+  def test_as_defined_dogs_do_bark
+    fido = Dog.new
+
+    assert_equal Exercises::AboutOpenClasses.koans.fetch(:as_defined_dogs_do_bark_one), fido.bark
+  end
+
+  # ------------------------------------------------------------------
+
+  # Open the existing Dog class and add a new method.
+  class Dog
+    # Demonstrates wag.
+    def wag
+      'HAPPY'
+    end
+  end
+
+  # Checks after reopening dogs can both wag and bark.
+  def test_after_reopening_dogs_can_both_wag_and_bark
+    fido = Dog.new
+
+    assert_equal Exercises::AboutOpenClasses.koans.fetch(:after_reopening_dogs_can_both_wag_and_bark_one), fido.wag
+    assert_equal Exercises::AboutOpenClasses.koans.fetch(:after_reopening_dogs_can_both_wag_and_bark_two), fido.bark
+  end
+
+  # ------------------------------------------------------------------
+
+  class ::Integer
+    # Demonstrates answer to life universe and everything?.
+    def answer_to_life_universe_and_everything?
+      self == 42
+    end
+  end
+
+  # Checks even existing built in classes can be reopened.
+  def test_even_existing_built_in_classes_can_be_reopened
+    assert_equal Exercises::AboutOpenClasses.koans.fetch(:even_existing_built_in_classes_can_be_reopened_one),
+                 1.answer_to_life_universe_and_everything?
+    assert_equal Exercises::AboutOpenClasses.koans.fetch(:even_existing_built_in_classes_can_be_reopened_two),
+                 42.answer_to_life_universe_and_everything?
+  end
+
+  # NOTE: To understand why we need the :: before Integer, you need to
+  # become enlightened about scope.
+end

data/test/exercises/about_pattern_matching_test.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+# Literal conditions isolate the control-flow behavior being predicted.
+# The example demonstrates that an unpinned variable pattern always binds the subject.
+# Keep the related original chapter examples together.
+# rubocop:disable Lint/LiteralAsCondition, Lint/UnreachablePatternBranch, Metrics/ClassLength
+
+# 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.
+
+require ARGV.shift
+class AboutPatternMatchingTest < Minitest::Test
+  # Checks pattern may not match.
+  def test_pattern_may_not_match
+    case [true, false]
+    in [a, b] if a == b # The condition after pattern is called guard.
+      :match
+    end
+  rescue NoMatchingPatternError => e
+    # What exception has been caught?
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:pattern_may_not_match_one), (e.class)
+  end
+
+  # Checks we can use else.
+  def test_we_can_use_else
+    result = case [true, false]
+             in [a, b] if a == b
+               :match
+             else
+               :no_match
+             end
+
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:we_can_use_else_one), result
+  end
+
+  # ------------------------------------------------------------------
+
+  # Demonstrates value pattern.
+  def value_pattern(variable)
+    case variable
+    in 0
+      :match_exact_value
+    in 1..10
+      :match_in_range
+    in Integer
+      :match_with_class
+    else
+      :no_match
+    end
+  end
+
+  # Checks value pattern.
+  def test_value_pattern
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:value_pattern_one), value_pattern(0)
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:value_pattern_two), value_pattern(5)
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:value_pattern_three), value_pattern(100)
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:value_pattern_four), value_pattern('Not a Number!')
+  end
+
+  # ------------------------------------------------------------------
+  # This pattern will bind variable to the value
+
+  # Demonstrates variable pattern with binding.
+  def variable_pattern_with_binding(variable)
+    case 0
+    in variable
+      variable
+    else
+      :no_match
+    end
+  end
+
+  # Checks variable pattern with binding.
+  def test_variable_pattern_with_binding
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:variable_pattern_with_binding_one),
+                 variable_pattern_with_binding(1)
+  end
+
+  # ------------------------------------------------------------------
+
+  # We can pin the value of the variable with ^
+
+  # Demonstrates variable pattern with pin.
+  def variable_pattern_with_pin(variable)
+    case 0
+    in ^variable
+      variable
+    else
+      :no_match
+    end
+  end
+
+  # Checks variable pattern with pin.
+  def test_variable_pattern_with_pin
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:variable_pattern_with_pin_one),
+                 variable_pattern_with_pin(1)
+  end
+
+  # ------------------------------------------------------------------
+
+  # We can drop values from pattern
+
+  # Demonstrates pattern with dropping.
+  def pattern_with_dropping(variable)
+    case variable
+    in [_, 2]
+      :match
+    else
+      :no_match
+    end
+  end
+
+  # Checks pattern with dropping.
+  def test_pattern_with_dropping
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:pattern_with_dropping_one),
+                 pattern_with_dropping(['I will not be checked', 2])
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:pattern_with_dropping_two),
+                 pattern_with_dropping(['I will not be checked', 'But I will!'])
+  end
+
+  # ------------------------------------------------------------------
+
+  # We can use logical *or* in patterns
+
+  # Demonstrates alternative pattern.
+  def alternative_pattern(variable)
+    case variable
+    in 0 | false | nil
+      :match
+    else
+      :no_match
+    end
+  end
+
+  # Checks alternative pattern.
+  def test_alternative_pattern
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:alternative_pattern_one), alternative_pattern(0)
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:alternative_pattern_two), alternative_pattern(false)
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:alternative_pattern_three), alternative_pattern(nil)
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:alternative_pattern_four), alternative_pattern(4)
+  end
+
+  # ------------------------------------------------------------------
+
+  # As pattern binds the variable to the value if pattern matches
+  # pat: pat => var
+
+  # Demonstrates as pattern.
+  def as_pattern
+    a = 'First I was afraid'
+
+    case 'I was petrified'
+    in String => a
+      a
+    else
+      :no_match
+    end
+  end
+
+  # Checks as pattern.
+  def test_as_pattern
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:as_pattern_one), as_pattern
+  end
+
+  # ------------------------------------------------------------------
+
+  # Array pattern works with all objects that have #deconstruct method that returns Array
+  # It is useful to cut needed parts from Array-ish objects
+
+  class Deconstructible
+    # Demonstrates initialize.
+    def initialize(str)
+      @data = str
+    end
+
+    # Demonstrates deconstruct.
+    def deconstruct
+      @data&.chars
+    end
+  end
+
+  # Demonstrates array pattern.
+  def array_pattern(deconstructible)
+    case deconstructible
+    in 'a', *res, 'd'
+      res
+    else
+      :no_match
+    end
+  end
+
+  # Checks array pattern.
+  def test_array_pattern
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:array_pattern_one),
+                 array_pattern(Deconstructible.new('abcd'))
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:array_pattern_two),
+                 array_pattern(Deconstructible.new('123'))
+  end
+
+  # ------------------------------------------------------------------
+
+  # Hash pattern is quite the same as Array pattern, but it expects #deconsturct_keys(keys) method
+  # It works with symbol keys for now
+
+  class LetterAccountant
+    # Demonstrates initialize.
+    def initialize(str)
+      @data = str
+    end
+
+    # Demonstrates deconstruct keys.
+    def deconstruct_keys(keys)
+      # we will count number of occurrences of each key in our data
+      keys.to_h { |key| [key, @data.count(key.to_s)] }
+    end
+  end
+
+  # Demonstrates hash pattern.
+  def hash_pattern(deconstructible_as_hash)
+    case deconstructible_as_hash
+    in { a: a, b: b }
+      [a, b]
+    else
+      :no_match
+    end
+  end
+
+  # Checks hash pattern.
+  def test_hash_pattern
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:hash_pattern_one),
+                 hash_pattern(LetterAccountant.new('aaabbc'))
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:hash_pattern_two),
+                 hash_pattern(LetterAccountant.new('xyz'))
+  end
+
+  # we can write it even shorter
+  # Demonstrates hash pattern with sugar.
+  def hash_pattern_with_sugar(deconstructible_as_hash)
+    case deconstructible_as_hash
+    in a:, b:
+      [a, b]
+    else
+      :no_match
+    end
+  end
+
+  # Checks hash pattern with sugar.
+  def test_hash_pattern_with_sugar
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:hash_pattern_with_sugar_one),
+                 hash_pattern_with_sugar(LetterAccountant.new('aaabbc'))
+    assert_equal Exercises::AboutPatternMatching.koans.fetch(:hash_pattern_with_sugar_two),
+                 hash_pattern_with_sugar(LetterAccountant.new('xyz'))
+  end
+end
+
+# rubocop:enable Lint/LiteralAsCondition, Lint/UnreachablePatternBranch, Metrics/ClassLength

data/test/exercises/about_proxy_object_project_test.rb

@@ -0,0 +1,75 @@
+# 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.
+
+require ARGV.shift
+
+class AboutProxyObjectProjectTest < Minitest::Test
+  # A receiver with state, arguments, keywords and a block.
+  class Television
+    attr_accessor :channel
+
+    # Toggle the current power state.
+    def power
+      @on = !@on
+    end
+
+    # @return [Boolean] current power state
+    def on?
+      !!@on
+    end
+
+    # Yield a formatted payload, keeping positional and keyword arguments distinct.
+    def broadcast(message, suffix: '!')
+      text = "#{message}#{suffix}"
+      block_given? ? yield(text) : text
+    end
+
+    private
+
+    # Private target behavior must stay inaccessible through the proxy.
+    def secret
+      :private
+    end
+  end
+
+  # State changes and exact message order must reach the real target.
+  def test_tv_methods_and_recorded_messages
+    tv = Exercises::AboutProxyObjectProject::Proxy.new(Television.new)
+    tv.power
+    tv.channel = 10
+
+    assert_equal %i[power channel=], tv.messages
+    assert_equal 10, tv.channel
+    assert_predicate tv, :on?
+    tv.power
+
+    assert tv.called?(:power)
+    refute tv.called?(:unseen)
+    assert_equal 2, tv.number_of_times_called(:power)
+    assert_equal 0, tv.number_of_times_called(:unseen)
+    assert_respond_to tv, :channel
+    refute_respond_to tv, :no_such_method
+    assert_raises(NoMethodError) { tv.no_such_method }
+    refute_respond_to tv, :secret
+    assert_raises(NoMethodError) { tv.secret }
+  end
+
+  # A proxy must work with other targets and propagate return values.
+  def test_string_target_and_return_values
+    proxy = Exercises::AboutProxyObjectProject::Proxy.new(+'Code Mash 2009')
+    proxy.upcase!
+
+    assert_equal %w[CODE MASH 2009], proxy.split
+    assert_equal %i[upcase! split], proxy.messages
+  end
+
+  # Forward keywords and the caller's block without treating keywords as a hash.
+  def test_keywords_and_blocks_reach_the_target
+    proxy = Exercises::AboutProxyObjectProject::Proxy.new(Television.new)
+
+    assert_equal 'RUBY?', proxy.broadcast('ruby', suffix: '?', &:upcase)
+  end
+end

data/test/exercises/about_regular_expressions_test.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+# The original descriptive check identifiers and example strings remain intact.
+# Keep the related original chapter examples together.
+# The examples contrast block forms and their behavior.
+# The examples explicitly demonstrate numbered regular-expression capture variables.
+# rubocop:disable Layout/LineLength, Metrics/ClassLength, Style/BlockDelimiters, Style/PerlBackrefs
+
+# 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.
+
+require ARGV.shift
+
+class AboutRegularExpressionsTest < Minitest::Test
+  # Checks a pattern is a regular expression.
+  def test_a_pattern_is_a_regular_expression
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:a_pattern_is_a_regular_expression_one),
+                 /pattern/.class
+  end
+
+  # Checks a regexp can search a string for matching content.
+  def test_a_regexp_can_search_a_string_for_matching_content
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:a_regexp_can_search_a_string_for_matching_content_one),
+                 'some matching content'[/match/]
+  end
+
+  # Checks a failed match returns nil.
+  def test_a_failed_match_returns_nil
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:a_failed_match_returns_nil_one),
+                 'some matching content'[/missing/]
+  end
+
+  # ------------------------------------------------------------------
+
+  # Checks question mark means optional.
+  def test_question_mark_means_optional
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:question_mark_means_optional_one),
+                 'abbcccddddeeeee'[/ab?/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:question_mark_means_optional_two),
+                 'abbcccddddeeeee'[/az?/]
+  end
+
+  # Checks plus means one or more.
+  def test_plus_means_one_or_more
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:plus_means_one_or_more_one), 'abbcccddddeeeee'[/bc+/]
+  end
+
+  # Checks asterisk means zero or more.
+  def test_asterisk_means_zero_or_more
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:asterisk_means_zero_or_more_one),
+                 'abbcccddddeeeee'[/ab*/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:asterisk_means_zero_or_more_two),
+                 'abbcccddddeeeee'[/az*/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:asterisk_means_zero_or_more_three),
+                 'abbcccddddeeeee'[/z*/]
+
+    # THINK ABOUT IT:
+    #
+    # When would * fail to match?
+  end
+
+  # THINK ABOUT IT:
+  #
+  # We say that the repetition operators above are "greedy."
+  #
+  # Why?
+
+  # ------------------------------------------------------------------
+
+  # Checks the left most match wins.
+  def test_the_left_most_match_wins
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:the_left_most_match_wins_one), 'abbccc az'[/az*/]
+  end
+
+  # ------------------------------------------------------------------
+
+  # Checks character classes give options for a character.
+  def test_character_classes_give_options_for_a_character
+    animals = %w[cat bat rat zat]
+
+    assert_equal(Exercises::AboutRegularExpressions.koans.fetch(:character_classes_give_options_for_a_character_one), animals.select { |a|
+      a[/[cbr]at/]
+    })
+  end
+
+  # Checks slash d is a shortcut for a digit character class.
+  def test_slash_d_is_a_shortcut_for_a_digit_character_class
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_d_is_a_shortcut_for_a_digit_character_class_one),
+                 'the number is 42'[/[0123456789]+/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_d_is_a_shortcut_for_a_digit_character_class_two),
+                 'the number is 42'[/\d+/]
+  end
+
+  # Checks character classes can include ranges.
+  def test_character_classes_can_include_ranges
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:character_classes_can_include_ranges_one),
+                 'the number is 42'[/[0-9]+/]
+  end
+
+  # Checks slash s is a shortcut for a whitespace character class.
+  def test_slash_s_is_a_shortcut_for_a_whitespace_character_class
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_s_is_a_shortcut_for_a_whitespace_character_class_one),
+                 "space: \t\n"[/\s+/]
+  end
+
+  # Checks slash w is a shortcut for a word character class.
+  def test_slash_w_is_a_shortcut_for_a_word_character_class
+    # NOTE:  This is more like how a programmer might define a word.
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_w_is_a_shortcut_for_a_word_character_class_one),
+                 'variable_1 = 42'[/[a-zA-Z0-9_]+/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_w_is_a_shortcut_for_a_word_character_class_two),
+                 'variable_1 = 42'[/\w+/]
+  end
+
+  # Checks period is a shortcut for any non newline character.
+  def test_period_is_a_shortcut_for_any_non_newline_character
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:period_is_a_shortcut_for_any_non_newline_character_one),
+                 "abc\n123"[/a.+/]
+  end
+
+  # Checks a character class can be negated.
+  def test_a_character_class_can_be_negated
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:a_character_class_can_be_negated_one),
+                 'the number is 42'[/[^0-9]+/]
+  end
+
+  # Checks shortcut character classes are negated with capitals.
+  def test_shortcut_character_classes_are_negated_with_capitals
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:shortcut_character_classes_are_negated_with_capitals_one),
+                 'the number is 42'[/\D+/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:shortcut_character_classes_are_negated_with_capitals_two),
+                 "space: \t\n"[/\S+/]
+    # ... a programmer would most likely do
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:shortcut_character_classes_are_negated_with_capitals_three),
+                 'variable_1 = 42'[/[^a-zA-Z0-9_]+/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:shortcut_character_classes_are_negated_with_capitals_four),
+                 'variable_1 = 42'[/\W+/]
+  end
+
+  # ------------------------------------------------------------------
+
+  # Checks slash a anchors to the start of the string.
+  def test_slash_a_anchors_to_the_start_of_the_string
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_a_anchors_to_the_start_of_the_string_one),
+                 'start end'[/\Astart/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_a_anchors_to_the_start_of_the_string_two),
+                 'start end'[/\Aend/]
+  end
+
+  # Checks slash z anchors to the end of the string.
+  def test_slash_z_anchors_to_the_end_of_the_string
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_z_anchors_to_the_end_of_the_string_one),
+                 'start end'[/end\z/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_z_anchors_to_the_end_of_the_string_two),
+                 'start end'[/start\z/]
+  end
+
+  # Checks caret anchors to the start of lines.
+  def test_caret_anchors_to_the_start_of_lines
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:caret_anchors_to_the_start_of_lines_one),
+                 "num 42\n2 lines"[/^\d+/]
+  end
+
+  # Checks dollar sign anchors to the end of lines.
+  def test_dollar_sign_anchors_to_the_end_of_lines
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:dollar_sign_anchors_to_the_end_of_lines_one),
+                 "2 lines\nnum 42"[/\d+$/]
+  end
+
+  # Checks slash b anchors to a word boundary.
+  def test_slash_b_anchors_to_a_word_boundary
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:slash_b_anchors_to_a_word_boundary_one),
+                 'bovine vines'[/\bvine./]
+  end
+
+  # ------------------------------------------------------------------
+
+  # Checks parentheses group contents.
+  def test_parentheses_group_contents
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:parentheses_group_contents_one), 'ahahaha'[/(ha)+/]
+  end
+
+  # ------------------------------------------------------------------
+
+  # Checks parentheses also capture matched content by number.
+  def test_parentheses_also_capture_matched_content_by_number
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:parentheses_also_capture_matched_content_by_number_one),
+                 'Gray, James'[/(\w+), (\w+)/, 1]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:parentheses_also_capture_matched_content_by_number_two),
+                 'Gray, James'[/(\w+), (\w+)/, 2]
+  end
+
+  # Checks variables can also be used to access captures.
+  def test_variables_can_also_be_used_to_access_captures
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:variables_can_also_be_used_to_access_captures_one),
+                 'Name:  Gray, James'[/(\w+), (\w+)/]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:variables_can_also_be_used_to_access_captures_two),
+                 ($1)
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:variables_can_also_be_used_to_access_captures_three),
+                 ($2)
+  end
+
+  # ------------------------------------------------------------------
+
+  # Checks a vertical pipe means or.
+  def test_a_vertical_pipe_means_or
+    grays = /(James|Dana|Summer) Gray/
+
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:a_vertical_pipe_means_or_one), 'James Gray'[grays]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:a_vertical_pipe_means_or_two),
+                 'Summer Gray'[grays, 1]
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:a_vertical_pipe_means_or_three), 'Jim Gray'[grays, 1]
+  end
+
+  # THINK ABOUT IT:
+  #
+  # Explain the difference between a character class ([...]) and alternation (|).
+
+  # ------------------------------------------------------------------
+
+  # Checks scan is like find all.
+  def test_scan_is_like_find_all
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:scan_is_like_find_all_one),
+                 'one two-three'.scan(/\w+/)
+  end
+
+  # Checks sub is like find and replace.
+  def test_sub_is_like_find_and_replace
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:sub_is_like_find_and_replace_one), 'one two-three'.sub(/(t\w*)/) {
+      $1[0, 1]
+    }
+  end
+
+  # Checks gsub is like find and replace all.
+  def test_gsub_is_like_find_and_replace_all
+    assert_equal Exercises::AboutRegularExpressions.koans.fetch(:gsub_is_like_find_and_replace_all_one), 'one two-three'.gsub(/(t\w*)/) {
+      $1[0, 1]
+    }
+  end
+end
+
+# rubocop:enable Layout/LineLength, Metrics/ClassLength, Style/BlockDelimiters, Style/PerlBackrefs