mutineer 1.0.2 → 1.2.0

data/lib/mutineer/minitest_integration/stop_at_first_failure.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Mutineer
+  class MinitestIntegration
+    # Stops a Minitest run at the first failing test: one failure already
+    # kills the mutant. Child-process only, like MinitestIntegration.
+    #
+    # It sets a flag instead of unwinding the stack, so that class-level
+    # wrappers (`after_all`, a block-form transaction) still finish. The
+    # remaining tests and classes then return before they start.
+    #
+    # Minitest 5 and 6 need different hook points. An unknown shape installs
+    # no hook, and the run is a full run.
+    module StopAtFirstFailure
+      # Prepended on `Minitest::CompositeReporter`.
+      module RecordFailure
+        # Records the result, then sets the stop flag on a failure or an
+        # error. Only the outer reporter counts: a test can build and record
+        # on its own reporter.
+        #
+        # @param result [Minitest::Result] the result of one test.
+        # @return [void]
+        def record(result)
+          super
+          return if result.passed? || result.skipped?
+          return unless equal?(StopAtFirstFailure.armed_reporter)
+          return unless StopAtFirstFailure.armed_here?
+
+          StopAtFirstFailure.stopped = true
+        end
+      end
+
+      # Prepended on the `Minitest` singleton class for Minitest 6.
+      module OuterReporter6
+        # Keeps the outer reporter. Only the first call counts, because a test
+        # can call this method with its own reporter.
+        #
+        # @param reporter [Minitest::CompositeReporter] the outer reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object] whatever Minitest returns.
+        def run_all_suites(reporter, options)
+          StopAtFirstFailure.armed_reporter ||= reporter if StopAtFirstFailure.armed_here?
+          super
+        end
+      end
+
+      # Prepended on the `Minitest` singleton class for Minitest 5.
+      module OuterReporter5
+        # The Minitest 5 form of OuterReporter6#run_all_suites.
+        #
+        # @param reporter [Minitest::CompositeReporter] the outer reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object] whatever Minitest returns.
+        def __run(reporter, options)
+          StopAtFirstFailure.armed_reporter ||= reporter if StopAtFirstFailure.armed_here?
+          super
+        end
+      end
+
+      # Prepended on the singleton class of each test class for Minitest 6.
+      module SkipAfterStop6
+        # Skips the test class after a stop.
+        #
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run_suite(reporter, options = {})
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+
+        # Skips one test after a stop, without a record.
+        #
+        # @param klass [Class] the test class.
+        # @param method_name [String] the test method.
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run(klass, method_name, reporter)
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+      end
+
+      # Prepended on the singleton class of each test class for Minitest 5.
+      module SkipAfterStop5
+        # Skips the test class after a stop.
+        #
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run(reporter, options = {})
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+
+        # Skips one test after a stop, without a record.
+        #
+        # @param klass [Class] the test class.
+        # @param method_name [String] the test method.
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run_one_method(klass, method_name, reporter)
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+      end
+
+      class << self
+        # The pid of the armed process. Forked workers inherit the other
+        # state, and the pid keeps them from acting on it.
+        #
+        # @return [Integer, nil]
+        attr_accessor :armed_pid
+
+        # The outer reporter of the armed run.
+        #
+        # @return [Minitest::CompositeReporter, nil]
+        attr_accessor :armed_reporter
+
+        # True after the outer reporter records a failure or an error.
+        #
+        # @return [Boolean, nil]
+        attr_accessor :stopped
+
+        # Installs the hooks and arms the stop for this process. Call it after
+        # the test files load, so that every test class gets its prepend.
+        #
+        # @param runnables [Array<Class>] the loaded test classes.
+        # @return [Boolean] false when the Minitest shape is unknown.
+        def arm!(runnables)
+          outer, skip = hooks_for_loaded_minitest
+          return false unless outer
+
+          prepend_once(::Minitest::CompositeReporter, RecordFailure)
+          prepend_once(::Minitest.singleton_class, outer)
+          runnables.each { |klass| prepend_once(klass.singleton_class, skip) }
+          self.armed_pid = Process.pid
+          self.armed_reporter = nil
+          self.stopped = false
+          true
+        end
+
+        # Clears the armed state.
+        #
+        # @return [void]
+        def disarm!
+          self.armed_pid = nil
+          self.armed_reporter = nil
+          self.stopped = false
+        end
+
+        # True when the run is armed in this process.
+        #
+        # @return [Boolean]
+        def armed_here?
+          armed_pid == Process.pid
+        end
+
+        # True when the armed run in this process has stopped.
+        #
+        # @return [Boolean]
+        def stopped_here?
+          stopped == true && armed_here?
+        end
+
+        private
+
+        # Picks the hook modules for the loaded Minitest.
+        #
+        # @return [Array(Module, Module), nil] the outer reporter hook and the
+        #   skip hook, or nil for an unknown shape.
+        def hooks_for_loaded_minitest
+          runnable = ::Minitest::Runnable
+          if ::Minitest.respond_to?(:run_all_suites) && runnable.respond_to?(:run_suite)
+            [OuterReporter6, SkipAfterStop6]
+          elsif ::Minitest.respond_to?(:__run) && runnable.respond_to?(:run_one_method)
+            [OuterReporter5, SkipAfterStop5]
+          end
+        end
+
+        # Prepends `mod` on `target` once. A copy on a superclass does not
+        # count, because it comes after the own methods of `target`.
+        #
+        # @param target [Module] the class or singleton class.
+        # @param mod [Module] the module to prepend.
+        # @return [void]
+        def prepend_once(target, mod)
+          return if target.ancestors.take_while { |a| !a.equal?(target) }.include?(mod)
+
+          target.prepend(mod)
+        end
+      end
+    end
+  end
+end

data/lib/mutineer/minitest_integration.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "stringio"
+require_relative "minitest_integration/stop_at_first_failure"
 
 module Mutineer
   # Child-process-only: loads a test file in the current process and runs it
@@ -16,6 +16,11 @@ module Mutineer
   # boundary for unexpected errors. Swallowing those here would create a
   # second exit-2 path and break this method's 0/1 return contract.
   class MinitestIntegration
+    # The seed of a run that stops at the first failure, unless `SEED` is set.
+    # With the stop, the test order can decide `killed` vs `timeout`; a fixed
+    # order keeps the verdict stable for a `--baseline` gate.
+    STOP_AT_FIRST_FAILURE_SEED = 1
+
     # Tested via runner_test.rb, not in isolation — a direct unit test
     # would require forking and duplicate isolation_test's coverage.
     #
@@ -24,8 +29,10 @@ module Mutineer
     # Minitest.run.
     #
     # @param test_files [String, Array<String>] one file or many files.
+    # @param stop_at_first_failure [Boolean] end the run at the first failing
+    #   test. Only the mutant path passes true.
     # @return [Integer] 0 on success, 1 on failure.
-    def self.run(test_files)
+    def self.run(test_files, stop_at_first_failure: false)
       begin
         require "minitest"
       rescue LoadError
@@ -47,13 +54,20 @@ module Mutineer
       Minitest::Runnable.reset
       Array(test_files).each { |f| load f }
 
-      orig = $stdout
-      # Silence the child's test output; the parent only cares about pass/fail.
-      $stdout = StringIO.new
-      passed = Minitest.run([])
-      $stdout = orig
+      args = []
+      if stop_at_first_failure && StopAtFirstFailure.arm!(Minitest::Runnable.runnables)
+        # Pin the seed only when the stop is armed; an unknown Minitest shape
+        # gets the normal full, randomly ordered run.
+        args = ["--seed", STOP_AT_FIRST_FAILURE_SEED.to_s] unless ENV["SEED"]
+      end
+      # No silencing here: the fork boundary that calls this method has already
+      # pointed stdout at File::NULL (see ChildStdout).
+      passed = Minitest.run(args)
 
-      passed ? 0 : 1
+      # A plugin can replace the summary reporter, so a stop decides by itself.
+      passed && !StopAtFirstFailure.stopped_here? ? 0 : 1
+    ensure
+      StopAtFirstFailure.disarm!
     end
   end
 end

data/lib/mutineer/mutator_registry.rb

@@ -11,12 +11,18 @@ require_relative "mutators/condition_negation"
 require_relative "mutators/string_literal"
 require_relative "mutators/regex_literal"
 require_relative "mutators/collection_method"
+require_relative "mutators/safe_navigation"
+require_relative "mutators/range_literal"
+require_relative "mutators/negation_removal"
+require_relative "mutators/chain_link"
+require_relative "mutators/operand_removal"
+require_relative "mutators/array_literal"
 
 module Mutineer
   # Maps operator names to operator classes.
   #
   # DEFAULT_NAMES is the v1 default set (Tier-1 plus statement-removal).
-  # The six Tier-2 operators live in ALL but are OFF by default — they only
+  # The Tier-2 operators live in ALL but are OFF by default — they only
   # run when named via `--operators` or `operators:` in `.mutineer.yml`.
   # Keeping DEFAULT_NAMES an explicit subset (not ALL.keys) is what keeps
   # the default survivor set unchanged.
@@ -33,13 +39,21 @@ module Mutineer
       "condition_negation" => Mutators::ConditionNegation,
       "string_literal"     => Mutators::StringLiteral,
       "regex"              => Mutators::RegexLiteral,
-      "collection_method"  => Mutators::CollectionMethod
+      "collection_method"  => Mutators::CollectionMethod,
+      "safe_navigation"    => Mutators::SafeNavigation,
+      "range"              => Mutators::RangeLiteral,
+      "negation_removal"   => Mutators::NegationRemoval,
+      "chain_link"         => Mutators::ChainLink,
+      "operand_removal"    => Mutators::OperandRemoval,
+      "array_literal"      => Mutators::ArrayLiteral
     }.freeze
 
     # The default Tier-1 operator set.
     DEFAULT_NAMES = %w[arithmetic comparison boolean_connector boolean_literal statement_removal].freeze
     # Tier-2 operators that remain opt-in.
-    TIER2_NAMES   = %w[return_nil literal_mutation condition_negation string_literal regex collection_method].freeze
+    TIER2_NAMES   = %w[return_nil literal_mutation condition_negation string_literal regex collection_method
+                       safe_navigation range negation_removal
+                       chain_link operand_removal array_literal].freeze
 
     # Short human-readable descriptions for each operator.
     DESCRIPTIONS = {
@@ -53,7 +67,13 @@ module Mutineer
       "condition_negation" => "wrap if/unless/ternary condition in !( ... )",
       "string_literal"     => "non-empty string -> \"\", empty string -> \"mutineer\"",
       "regex"              => "drop leading ^ / trailing $, swap + <-> *",
-      "collection_method"  => "map<->each, all?<->any?, first<->last, min<->max, select<->reject"
+      "collection_method"  => "map<->each, all?<->any?, first<->last, min<->max, select<->reject",
+      "safe_navigation"    => "&. -> .",
+      "range"              => ".. <-> ...",
+      "negation_removal"   => "!x, not x -> x",
+      "chain_link"         => "drop one call from a chain: a.b.c -> a.c",
+      "operand_removal"    => "a && b -> a, b",
+      "array_literal"      => "[a, b] -> []"
     }.freeze
 
     # Resolves operator names to classes.

data/lib/mutineer/mutators/array_literal.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Array-literal mutator (Tier-2).
+    #
+    # Replaces a non-empty array literal with an empty one, one mutation per
+    # literal: `[a, b]` and `%i[a b]` become `[]`. The mutant survives when no
+    # test checks the contents of the array.
+    class ArrayLiteral < Base
+      # Visits array nodes and emits array-literal mutations.
+      #
+      # @param node [Prism::ArrayNode] array node to inspect.
+      # @return [void]
+      def visit_array_node(node)
+        emit(node)
+        super # nested arrays each get their own mutation
+      end
+
+      # Skips a nested method definition. The project finds it as a subject of
+      # its own, so a visit here counts its arrays twice.
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node); end
+
+      private
+
+      # Emits a mutation for a non-empty array with brackets.
+      #
+      # The operator skips an implicit array (`x = 1, 2`), because it has no
+      # brackets. It also skips an array that holds a heredoc, because the
+      # heredoc body stays behind as code.
+      #
+      # @param node [Prism::ArrayNode] array node to inspect.
+      # @return [void]
+      def emit(node)
+        return if node.opening_loc.nil? || node.elements.empty? || heredoc?(node)
+
+        @mutations << Mutation.new(
+          start_offset: node.location.start_offset,
+          end_offset: node.location.end_offset,
+          replacement: "[]",
+          operator: :array_literal
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/base.rb

@@ -26,6 +26,21 @@ module Mutineer
         subject.def_node.body&.accept(self)
         @mutations
       end
+
+      private
+
+      # Returns whether a node is, or contains, a heredoc.
+      #
+      # A heredoc's body lies outside its node's byte range. A mutation that
+      # deletes the node leaves the body behind as code, so the mutant
+      # always raises.
+      #
+      # @param node [Prism::Node] node to inspect.
+      # @return [Boolean] true when a heredoc is inside the node.
+      def heredoc?(node)
+        (node.respond_to?(:heredoc?) && node.heredoc?) ||
+          node.compact_child_nodes.any? { |child| heredoc?(child) }
+      end
     end
   end
 end

data/lib/mutineer/mutators/chain_link.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Chain-link mutator (Tier-2).
+    #
+    # Drops one dotted call from a chain of calls, with its arguments and block:
+    # `user.account.owner.name` becomes `user.owner.name` and `user.account.name`.
+    # The chain's receiver and its final call stay, so a chain of n dotted calls
+    # gives at most n - 1 mutations. A chain begins at a receiver that is not a
+    # dotted call: a local, a constant, `self`, `list[i]`, `(a + b)`. A call in
+    # an argument or a block starts a chain of its own.
+    #
+    # The mutant survives when no test tells the chain apart from the same chain
+    # without that step: a scope, a filter or a lookup the tests never see.
+    #
+    # Links in {SKIPPED} are never dropped. On a value that already has the
+    # target type or needs no copy, a conversion (`name.to_s.strip`) or a copy
+    # (`list.dup.sort`) is a no-op, so dropping it most often makes an
+    # equivalent mutant. Dropping `new` sends the next call to the class, which
+    # raises (killed by any test that runs the line) or reaches a class method
+    # that builds the instance itself (equivalent); neither says anything about
+    # the tests.
+    class ChainLink < Base
+      # Method names whose link is never dropped: core conversions and copies,
+      # plus `new`.
+      SKIPPED = %i[
+        to_s to_str to_sym to_i to_int to_f to_r to_c to_a to_ary to_h to_hash to_proc to_set
+        dup clone freeze itself
+        new
+      ].freeze
+
+      # Resets the per-subject record of calls already placed in a chain.
+      #
+      # @param subject [Mutineer::Subject] subject whose body is visited.
+      # @param source [String] full source text for byte-based slicing.
+      # @return [Array<Mutineer::Mutation>] collected mutations.
+      def mutations_for(subject, source)
+        @links = {}.compare_by_identity
+        super
+      end
+
+      # Visits a call. The outermost dotted call of a chain is its final call;
+      # the dotted calls below it in the receiver are its links.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        chain(node) if dotted?(node) && !@links.key?(node)
+        super
+      end
+
+      # Visits `a.b.c += 1`, whose final call Prism parses as its own node.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c ||= 1`.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c &&= 1`.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `a.b.c, d = 1, 2`.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        chain(node)
+        super
+      end
+
+      # Nested method definitions are discovered as their own subjects; do not
+      # recurse into them (prevents double-counting their chains).
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node); end
+
+      private
+
+      # Walks a final call's receiver chain, recording each link so it is not
+      # taken for the final call of a chain of its own, and dropping each link
+      # not in {SKIPPED}.
+      #
+      # @param top [Prism::Node] the chain's final call; responds to `receiver`.
+      # @return [void]
+      def chain(top)
+        link = top.receiver
+        while dotted?(link)
+          @links[link] = true
+          drop(link) unless SKIPPED.include?(link.name)
+          link = link.receiver
+        end
+      end
+
+      # Emits the removal of one link: from the end of its receiver to the end
+      # of its arguments and block, so a chain split across lines keeps the
+      # layout of the lines that remain.
+      #
+      # @param link [Prism::CallNode] the dotted call to drop.
+      # @return [void]
+      def drop(link)
+        @mutations << Mutation.new(
+          start_offset: link.receiver.location.end_offset,
+          end_offset: link.location.end_offset,
+          replacement: "",
+          operator: :chain_link
+        )
+      end
+
+      # Returns whether a node is a call through `.`, `&.` or `::`.
+      #
+      # @param node [Prism::Node, nil] node to inspect.
+      # @return [Boolean] true for a call node with a call operator.
+      def dotted?(node)
+        node.is_a?(Prism::CallNode) && !node.call_operator_loc.nil?
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/negation_removal.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Negation-removal mutator (Tier-2).
+    #
+    # Removes the `!` or `not` of a negation, one mutation per occurrence:
+    # `!x` becomes `x` and `not x` becomes ` x`. The mutant survives when no
+    # test depends on the negated value.
+    class NegationRemoval < Base
+      # Visits call nodes and emits negation-removal mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        emit(node)
+        super # nested negations (!!x) each get their own mutation
+      end
+
+      private
+
+      # Emits a mutation when the node is a prefix `!` or `not`.
+      #
+      # The explicit form `x.!` is skipped: without its message, `x.` does
+      # not parse.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def emit(node)
+        return unless node.name == :! && node.call_operator_loc.nil?
+
+        loc = node.message_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: "",
+          operator: :negation_removal
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/operand_removal.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Operand-removal mutator (Tier-2).
+    #
+    # Replaces a boolean expression with one of its operands, two mutations
+    # per `&&`, `||`, `and` or `or`: `a && b` becomes `(a)` and `(b)`. The
+    # parentheses keep the precedence of `and` and `or`. A surviving mutant
+    # shows that no test needs the operand that was removed.
+    class OperandRemoval < Base
+      # Node types for jumps. A jump in a value context does not parse, so
+      # the operator never keeps a jump alone.
+      JUMPS = [Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode, Prism::RetryNode].freeze
+
+      # Visits `and` nodes.
+      #
+      # @param node [Prism::AndNode] node to inspect.
+      # @return [void]
+      def visit_and_node(node)
+        emit(node)
+        super # nested connectors (a && b && c) each get their own mutations
+      end
+
+      # Visits `or` nodes.
+      #
+      # @param node [Prism::OrNode] node to inspect.
+      # @return [void]
+      def visit_or_node(node)
+        emit(node)
+        super
+      end
+
+      # Skips a nested method definition. The project finds it as a subject of
+      # its own, so a visit here counts its connectors twice.
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node); end
+
+      private
+
+      # Emits one mutation that keeps the left operand, then one that keeps
+      # the right operand. The order is fixed, because the two mutants share
+      # a token and their occurrence ordinals tell them apart.
+      #
+      # @param node [Prism::AndNode, Prism::OrNode] connector node.
+      # @return [void]
+      def emit(node)
+        [[node.left, node.right], [node.right, node.left]].each do |kept, removed|
+          next if JUMPS.any? { |type| kept.is_a?(type) } || heredoc?(removed)
+
+          @mutations << Mutation.new(
+            start_offset: node.location.start_offset,
+            end_offset: node.location.end_offset,
+            replacement: "(#{kept.slice})",
+            operator: :operand_removal
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/range_literal.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Range mutator (Tier-2).
+    #
+    # Swaps `..` with `...` and `...` with `..`, one mutation per range. The
+    # `..` -> `...` mutant survives when no test checks the last element.
+    # Flip-flops are FlipFlopNode, not RangeNode, so this mutator skips them.
+    #
+    # Endless ranges (`1..`, `1..nil`) are skipped. `(1..)` and `(1...)` give
+    # the same result for slicing, `include?`, `===`, `size` and patterns, so
+    # the mutant is equivalent and no normal test can kill it.
+    class RangeLiteral < Base
+      # Maps each range operator to its opposite.
+      SWAPS = { ".." => "...", "..." => ".." }.freeze
+
+      # Visits range nodes and emits range mutations.
+      #
+      # @param node [Prism::RangeNode] range node to inspect.
+      # @return [void]
+      def visit_range_node(node)
+        emit(node) unless endless?(node)
+        super # nested ranges ((1..2)...(3..4)) each get their own mutation
+      end
+
+      private
+
+      # Whether the range has no end: `1..` or `1..nil`.
+      #
+      # @param node [Prism::RangeNode] range node to inspect.
+      # @return [Boolean]
+      def endless?(node)
+        node.right.nil? || node.right.is_a?(Prism::NilNode)
+      end
+
+      # Emits the mutation that swaps the range operator.
+      #
+      # @param node [Prism::RangeNode] range node to mutate.
+      # @return [void]
+      def emit(node)
+        loc = node.operator_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: SWAPS.fetch(loc.slice),
+          operator: :range
+        )
+      end
+    end
+  end
+end