mutineer 1.6.0 → 1.7.0

data/lib/mutineer/mutator_registry.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "config"
 require_relative "mutators/arithmetic"
 require_relative "mutators/comparison"
 require_relative "mutators/boolean_connector"
@@ -15,6 +16,7 @@ require_relative "mutators/safe_navigation"
 require_relative "mutators/range_literal"
 require_relative "mutators/negation_removal"
 require_relative "mutators/chain_link"
+require_relative "mutators/call_to_receiver"
 require_relative "mutators/operand_removal"
 require_relative "mutators/array_literal"
 require_relative "mutators/condition_forcing"
@@ -46,6 +48,7 @@ module Mutineer
       "range"              => Mutators::RangeLiteral,
       "negation_removal"   => Mutators::NegationRemoval,
       "chain_link"         => Mutators::ChainLink,
+      "call_to_receiver"   => Mutators::CallToReceiver,
       "operand_removal"    => Mutators::OperandRemoval,
       "array_literal"      => Mutators::ArrayLiteral,
       "condition_true"     => Mutators::ConditionTrue,
@@ -58,7 +61,7 @@ module Mutineer
     # Tier-2 operators that remain opt-in.
     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
+                       chain_link call_to_receiver operand_removal array_literal
                        condition_true condition_false operator_assignment].freeze
 
     # Short human-readable descriptions for each operator.
@@ -78,6 +81,7 @@ module Mutineer
       "range"              => ".. <-> ...",
       "negation_removal"   => "!x, not x -> x",
       "chain_link"         => "drop one call from a chain: a.b.c -> a.c",
+      "call_to_receiver"   => "drop the last call of a chain: foo.bar -> foo",
       "operand_removal"    => "a && b -> a, b",
       "array_literal"      => "[a, b] -> []",
       "condition_true"     => "if/elsif/unless/ternary/modifier/case-in guard condition -> true",
@@ -91,7 +95,7 @@ module Mutineer
     # @return [Array<Class>] mutator classes in the requested order.
     # @raise [ArgumentError] when a name is unknown.
     def self.resolve(names = DEFAULT_NAMES)
-      names.map { |n| ALL.fetch(n) { raise ArgumentError, "Unknown operator: #{n.inspect}" } }
+      names.map { |n| ALL.fetch(n) { raise ArgumentError, "Unknown operator: #{n.inspect}#{Mutineer.did_you_mean(n, ALL.keys)}" } }
     end
 
     # Returns whether the operator is part of the default Tier-1 set.

data/lib/mutineer/mutators/base.rb

@@ -52,24 +52,27 @@ module Mutineer
 
       private
 
-      # Drops a mutation that deletes a heredoc opener and leaves its body.
+      # Drops a mutation that splits a heredoc opener from its body.
       #
       # The body sits past the opener's node. Replacing the opener with text
       # that does not contain it turns the body into Ruby, which parses and
       # then raises. A replacement that still contains the opener keeps the
-      # body attached, so that mutation stays.
+      # body attached, so that mutation stays. The reverse also breaks: when
+      # the replaced range holds the body but the replacement keeps only the
+      # opener, the opener has no body and the source does not parse. A
+      # replacement that copies the opener and the body together stays.
       #
       # @return [void]
       def drop_dangling_heredocs
         @mutations.reject! { |mutation| dangling_heredoc?(mutation) }
       end
 
-      # Returns whether the mutation removes a heredoc opener whose body hangs
-      # past the replaced range.
+      # Returns whether the mutation replaces a heredoc opener and keeps the
+      # opener without its body, or the body without its opener.
       #
       # @param mutation [Mutineer::Mutation] candidate edit.
       # @param node [Prism::Node, nil] subtree to search. Defaults to the body.
-      # @return [Boolean] true when the edit would leave a heredoc body behind.
+      # @return [Boolean] true when the edit would split a heredoc from its body.
       def dangling_heredoc?(mutation, node = @body)
         return false if node.nil? || !node.is_a?(Prism::Node)
 
@@ -78,9 +81,13 @@ module Mutineer
           if opening && opening.start_offset >= mutation.start_offset && opening.start_offset < mutation.end_offset
             closing = node.respond_to?(:closing_loc) ? node.closing_loc : nil
             hangs = closing.nil? || closing.end_offset > mutation.end_offset
+            opener = @source.byteslice(opening.start_offset, opening.end_offset - opening.start_offset)
+            kept = !opener.empty? && mutation.replacement.include?(opener)
             if hangs
-              opener = @source.byteslice(opening.start_offset, opening.end_offset - opening.start_offset)
-              return true if opener.empty? || !mutation.replacement.include?(opener)
+              return true unless kept
+            elsif kept
+              whole = @source.byteslice(opening.start_offset, closing.end_offset - opening.start_offset)
+              return true unless mutation.replacement.include?(whole)
             end
           end
         end

data/lib/mutineer/mutators/call_to_receiver.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "chain_link"
+
+module Mutineer
+  module Mutators
+    # Call-to-receiver mutator (Tier-2).
+    #
+    # Replaces the last call of a chain with its receiver, with the arguments
+    # and the block of that call: `user.full_name` becomes `user`, and
+    # `ids.uniq.sort` becomes `ids.uniq`. A chain begins at a receiver that is
+    # not a dotted call, as in {ChainLink}. A call in an argument or a block
+    # starts a chain of its own.
+    #
+    # The mutant survives when no test checks what the last call does: a strip,
+    # a uniq, a compact or a lookup the tests never see.
+    #
+    # The operator does not overlap with {ChainLink}. `chain_link` drops a link
+    # in the middle of a chain, and this operator drops the last call. A call
+    # that is the receiver of a dotted call, or of a call write or a call
+    # target, is a link, so it gets no mutant here. The two operators give the
+    # same source only when the last call repeats the link before it, as in
+    # `node.name.name`.
+    #
+    # Calls in {ChainLink::SKIPPED} are never replaced. On the last call,
+    # `x.to_s` is the same as `x` for the same reason as on a link. `Foo.new`
+    # becomes the class, and almost any use of the class raises.
+    #
+    # A call is not replaced when its name is an operator (`a.+(1)`), or a
+    # setter (`a.b = 1`). A call with no dot (`a + b`, `a[0]`) is not replaced.
+    class CallToReceiver < Base
+      # Matches the name of a call written as a word, not as an operator.
+      WORD_NAME = /\A[[:alpha:]_]/
+
+      # Resets the per-subject record of calls that are links.
+      #
+      # @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. A dotted call that is not a link is the last call of its
+      # chain.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        mark(node)
+        replace(node) if dotted?(node) && !@links.key?(node)
+        super
+      end
+
+      # Visits `a.b.c += 1`. Its receiver is a link.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        mark(node)
+        super
+      end
+
+      # Visits `a.b.c ||= 1`. Its receiver is a link.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        mark(node)
+        super
+      end
+
+      # Visits `a.b.c &&= 1`. Its receiver is a link.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        mark(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `a.b.c, d = 1, 2`.
+      # Its receiver is a link.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        mark(node)
+        super
+      end
+
+      private
+
+      # Records the receiver of a node as a link when the node is a dotted call
+      # or a call write or target. The receiver of a call with no dot is not a
+      # link. It is the last call of a chain of its own.
+      #
+      # @param node [Prism::Node] node that responds to `receiver`.
+      # @return [void]
+      def mark(node)
+        @links[node.receiver] = true if dotted?(node) || !node.is_a?(Prism::CallNode)
+      end
+
+      # Emits the replacement of a call by its receiver, unless the name is an
+      # operator, a setter, or in {ChainLink::SKIPPED}.
+      #
+      # @param node [Prism::CallNode] the dotted call to replace.
+      # @return [void]
+      def replace(node)
+        name = node.name.to_s
+        return unless name.match?(WORD_NAME)
+        return if name.end_with?("=")
+        return if ChainLink::SKIPPED.include?(node.name)
+
+        receiver = node.receiver.location
+        @mutations << Mutation.new(
+          start_offset: node.location.start_offset,
+          end_offset: node.location.end_offset,
+          replacement: @source.byteslice(receiver.start_offset, receiver.end_offset - receiver.start_offset),
+          operator: :call_to_receiver
+        )
+      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/chain_link.rb

@@ -25,7 +25,7 @@ module Mutineer
     # the tests.
     class ChainLink < Base
       # Method names whose link is never dropped: core conversions and copies,
-      # plus `new`.
+      # plus `new`. {CallToReceiver} uses the same list for the last call.
       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

data/lib/mutineer/orphan_guard.rb

@@ -10,6 +10,10 @@ module Mutineer
   module OrphanGuard
     # Seconds between checks. A forked child gets no signal on parent death.
     POLL = 0.5
+    # `Tempfile.create([".mutineer_daemon", ".rb"])` names the file
+    # `.mutineer_daemon<YYYYMMDD>-<pid>-<rand>.rb` (without the dot before #253).
+    # The pid is the child that is loading the mutant.
+    DAEMON_TEMP_PID = /\A\.?mutineer_daemon\d{8}-(\d+)-/
 
     # Starts the watchdog in the current (child) process.
     #
@@ -24,5 +28,73 @@ module Mutineer
         Process.kill(:KILL, Process.getpgrp == Process.pid ? 0 : Process.pid)
       end
     end
+
+    # True when a daemon mutant file still belongs to a live process. A boot
+    # sweep must leave it alone. The database lock is taken later, so the
+    # sweep is the step that used to delete another run's file.
+    #
+    # The creating pid is in the file name. A process that still holds the
+    # file lock counts too, even when that pid is already gone. A dead pid
+    # and a free lock is an orphan a killed child left behind.
+    #
+    # @param path [String] absolute path of a `.mutineer_daemon*.rb` file.
+    # @return [Boolean]
+    def self.mutant_file_in_use?(path)
+      creator_alive?(path) || locked_by_another?(path)
+    end
+
+    # True when the pid embedded in a daemon mutant file name is still running.
+    # Pid 0 is this process group, so it is never treated as an owner.
+    #
+    # @param path [String]
+    # @return [Boolean]
+    def self.creator_alive?(path)
+      pid_text = File.basename(path)[DAEMON_TEMP_PID, 1]
+      return false unless pid_text
+
+      pid = Integer(pid_text, 10)
+      return false if pid <= 0
+
+      Process.kill(0, pid)
+      !zombie?(pid)
+    rescue Errno::ESRCH, Errno::EINVAL, RangeError
+      false
+    rescue SystemCallError
+      true
+    end
+
+    # True when `pid` has exited but nobody reaped it. A container whose pid 1
+    # does not reap orphans keeps a dead mutant child as a zombie for good, and
+    # `Process.kill(0)` still finds it (#250). Linux only: elsewhere there is no
+    # `/proc`, so a zombie still counts as running.
+    #
+    # @param pid [Integer]
+    # @return [Boolean]
+    def self.zombie?(pid)
+      stat = File.read("/proc/#{pid}/stat")
+      # The name before the state is in parentheses and may hold ") " itself.
+      # An empty read (the process exited mid-read) has no ")": not a zombie.
+      close = stat.rindex(")")
+      !close.nil? && stat[close + 2] == "Z"
+    rescue SystemCallError
+      false
+    end
+
+    # True when another process holds an exclusive lock on `path`. A lock the
+    # kernel rejects as unsupported is not ownership: the pid check still applies.
+    # A file we cannot inspect is left in place.
+    #
+    # @param path [String]
+    # @return [Boolean]
+    def self.locked_by_another?(path)
+      File.open(path, File::RDONLY) do |file|
+        file.flock(File::LOCK_EX | File::LOCK_NB) == false
+      end
+    rescue Errno::ENOENT, Errno::ENOTSUP, Errno::EOPNOTSUPP
+      false
+    rescue SystemCallError
+      true
+    end
+    private_class_method :creator_alive?, :zombie?, :locked_by_another?
   end
 end

data/lib/mutineer/project.rb

@@ -31,6 +31,9 @@ module Mutineer
       # Calls whose block is the body of the class they build: receiver name => method.
       CLASS_BUILDERS = { "Data" => :define, "Struct" => :new, "Class" => :new, "Module" => :new }.freeze
 
+      # ActiveSupport::Concern calls whose block another module or class runs (see {#concern_block}).
+      CONCERN_BLOCKS = %i[class_methods included prepended].freeze
+
       # A constant name, or a path of them; Ruby allows Unicode in both.
       CONSTANT_PATH = /\A[[:upper:]][[:word:]]*(?:::[[:upper:]][[:word:]]*)*\z/
 
@@ -78,6 +81,8 @@ module Mutineer
         @self_unknown = false      # inside a def or a block that is not a builder, so `self` is not the namespace
         @self_scope = nil          # the def or block whose `self` the code runs with
         @singleton_uncertain = false # the open `class << self` was inside a def or a non-builder block
+        @concern_modules = Set.new   # the {#module_key} of each module that ran `extend ActiveSupport::Concern`
+        @hook_block = false          # inside a concern's `included` or `prepended` block (see {#hook_block?})
         super()
       end
 
@@ -117,7 +122,11 @@ module Mutineer
       # block's defs belong to the class it builds; one not assigned to a
       # constant has no name, so its subjects are marked `owner_unknown`, and a
       # `module_function :name` in it promotes nothing. Elsewhere it promotes the
-      # methods of the same module, matched by {#module_key}.
+      # methods of the same module, matched by {#module_key}. A module that runs
+      # `extend ActiveSupport::Concern` is a concern from then on in this file. A
+      # `class_methods` block in its body (see {#concern_block}) is visited like a
+      # builder block that builds the module's `ClassMethods`, so its defs belong to
+      # that module (#252). The defs in any other such block have their owner unknown.
       #
       # @param node [Prism::CallNode] call node.
       # @return [void]
@@ -136,10 +145,30 @@ module Mutineer
             end
           end
         end
-        return super unless builds_class?(node)
-
-        anonymous = !@assigned&.first.equal?(node)
-        with_block_owner(anonymous ? [nil, @namespace_stack, true] : @assigned.last, anonymous) do
+        if node.name == :extend && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)) &&
+           !@self_unknown && @singleton_depth.zero?
+          args = node.arguments&.arguments || []
+          concern = args.any? { |arg| arg.slice.delete_prefix("::") == "ActiveSupport::Concern" }
+          @concern_modules << module_key if concern
+        end
+        case concern_block(node)
+        when :owner_unknown
+          hook = hook_block?(node)
+          return preserving_scope do
+            @hook_block ||= hook
+            @owner_unknown = true
+            super
+          end
+        when :class_methods
+          owner = named_owner((@block_namespace || @namespace_stack) + ["ClassMethods"])
+          anonymous = false
+        else
+          return super unless builds_class?(node)
+
+          anonymous = !@assigned&.first.equal?(node)
+          owner = anonymous ? [nil, @namespace_stack, true] : @assigned.last
+        end
+        with_block_owner(owner, anonymous) do
           @self_scope = node.block
           super
         end
@@ -221,6 +250,7 @@ module Mutineer
           lexical: @lexical_stack.dup,
           block_owner: @block_owner,
           owner_unknown: @owner_unknown,
+          hook_block: @hook_block,
           name: node.name,
           singleton: !node.receiver.nil? || @singleton_depth.positive? || @module_function_active,
           def_node: node
@@ -331,7 +361,7 @@ module Mutineer
       # Visitor state a class/module body or builder block sets for what it contains.
       SCOPE_STATE = %i[@namespace_stack @lexical_stack @module_function_active @block_owner @block_namespace
                        @owner_unknown @singleton_depth @singleton_cref @namespace_unknown @anonymous_block @body
-                       @self_unknown @self_scope @singleton_uncertain].freeze
+                       @self_unknown @self_scope @singleton_uncertain @hook_block].freeze
 
       # Runs the block and then restores every {SCOPE_STATE} variable, so a
       # nested body's state never leaks out of it.
@@ -448,6 +478,50 @@ module Mutineer
           CLASS_BUILDERS[node.receiver&.slice&.delete_prefix("::")] == node.name
       end
 
+      # Sorts an ActiveSupport::Concern block by where redefine can load its defs.
+      # ActiveSupport evaluates a `class_methods` block in the module's `ClassMethods`,
+      # which it extends onto every includer, so the test calls `Includer.name` on
+      # that module's method, not on the concern (#252). In a class or module body,
+      # or a builder block, with a known owner, that module is `<namespace>::ClassMethods`.
+      # The block keeps the lexical scope, so redefine reopens the concern's chain and
+      # loads the mutant with `::Concern::ClassMethods.class_eval`. In a def, a block
+      # that does not build a class (Rails' `concerning :Name do`), `class << self`, or
+      # under an owner no constant names (an unassigned `Module.new`), no constant here
+      # names that `ClassMethods`. ActiveSupport evaluates an `included` or `prepended`
+      # block in each includer, which no constant names either. The call has no
+      # receiver or `self`, no arguments, and a block.
+      #
+      # Another library can define methods with these names and run the block in
+      # the module itself. So a `class_methods` block counts only in a module that ran
+      # `extend ActiveSupport::Concern` earlier in this file, in this body or an earlier
+      # one ({#module_key}). Any other block with these names is unplaceable: guessing
+      # its owner would load a mutant where the tests never call it.
+      #
+      # @param node [Prism::CallNode] call node.
+      # @return [Symbol, nil] `:class_methods` when redefine can name the module,
+      #   `:owner_unknown` for any other Concern block, or nil for any other call.
+      def concern_block(node)
+        return unless CONCERN_BLOCKS.include?(node.name) && node.arguments.nil? && node.block.is_a?(Prism::BlockNode)
+        return unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+        placeable = node.name == :class_methods && !@self_unknown && @singleton_depth.zero? && !@owner_unknown &&
+                    @concern_modules.include?(module_key)
+        placeable ? :class_methods : :owner_unknown
+      end
+
+      # True for an `included` or `prepended` block of a module that ran `extend
+      # ActiveSupport::Concern` earlier in this file (see {#concern_block}).
+      # ActiveSupport runs the block only when a class first includes or prepends
+      # the concern, so loading the file again stores the new block but never
+      # runs it in a class that already has the concern (#256). Everything the
+      # block defines, a nested class or a builder block included, stays as the
+      # original wrote it under `--strategy reload`.
+      #
+      # @param node [Prism::CallNode] a call {#concern_block} sorted as a concern block.
+      # @return [Boolean]
+      def hook_block?(node)
+        %i[included prepended].include?(node.name) && @concern_modules.include?(module_key)
+      end
+
       # Runs the block with the defs it visits owned by the class a builder block builds.
       # The block body defines instance methods of that class, even inside `class << self`,
       # but its constants still land where the enclosing `class << self` puts them.

data/lib/mutineer/rails_run_env.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Mutineer
+  # Pins the environment Rails and Spring read during a mutant run.
+  #
+  # Rails reads +PARALLEL_WORKERS+ inside +parallelize+ and uses it instead of
+  # the +workers:+ argument. A value of 1 keeps that run in one process.
+  # +--test-command+ also sets +DISABLE_SPRING+ so the Spring preloader does
+  # not start. {pin_process!} prints the replacement line once. The caller
+  # puts the process value back with {restore_process!} when the run ends.
+  module RailsRunEnv
+    # Value of +PARALLEL_WORKERS+ that keeps Rails test workers off.
+    PARALLEL_WORKERS = "1"
+
+    # Value of +DISABLE_SPRING+ that stops the Spring preloader.
+    DISABLE_SPRING = "1"
+
+    # Sets +PARALLEL_WORKERS+ to {PARALLEL_WORKERS} in this process.
+    # Prints one line when the previous value is set and is not already 1.
+    #
+    # @return [void]
+    def self.pin_process!
+      current = ENV["PARALLEL_WORKERS"]
+      warn(replacement_line(current)) if replace?(current)
+      ENV["PARALLEL_WORKERS"] = PARALLEL_WORKERS
+      nil
+    end
+
+    # Puts the caller's +PARALLEL_WORKERS+ back. +nil+ means it was unset.
+    #
+    # @param previous [String, nil]
+    # @return [void]
+    def self.restore_process!(previous)
+      if previous.nil?
+        ENV.delete("PARALLEL_WORKERS")
+      else
+        ENV["PARALLEL_WORKERS"] = previous
+      end
+      nil
+    end
+
+    # Forces +PARALLEL_WORKERS+ on a child environment.
+    # +spring+ also sets +DISABLE_SPRING+. The hash is the spawn delta or the
+    # full daemon environment. This does not change the parent process.
+    #
+    # @param env [Hash{String => String, nil}]
+    # @param spring [Boolean] set +DISABLE_SPRING+ when true.
+    # @return [void]
+    def self.pin_child!(env, spring: false)
+      env["PARALLEL_WORKERS"] = PARALLEL_WORKERS
+      env["DISABLE_SPRING"] = DISABLE_SPRING if spring
+      nil
+    end
+
+    # True when Mutineer must replace a +PARALLEL_WORKERS+ value the user set.
+    #
+    # @param current [String, nil]
+    # @return [Boolean]
+    def self.replace?(current)
+      !current.nil? && current != PARALLEL_WORKERS
+    end
+
+    # The one line printed when {replace?} is true.
+    #
+    # @param current [String]
+    # @return [String]
+    def self.replacement_line(current)
+      "[mutineer] PARALLEL_WORKERS was #{current.inspect}; using 1 so each mutant's tests run in one process. " \
+        "Unset it or set it to 1 to drop this line."
+    end
+    private_class_method :replace?, :replacement_line
+  end
+end