mutineer 1.7.0 → 1.8.0

data/lib/mutineer/pairing.rb

@@ -4,7 +4,7 @@ require_relative "project_path"
 
 module Mutineer
   # Source -> test pairing by path convention (#11). Pure stdlib path logic:
-  # no Rails, no class loading, no process. Two jobs:
+  # no Rails, no class loading, no process. Three jobs:
   #   * expand_sources — a directory argument becomes its sorted **/*.rb files;
   #                     a file inside the root becomes its root-relative path.
   #   * infer_tests    — a source's test files by convention (app/ and lib/
@@ -13,6 +13,9 @@ module Mutineer
   #                     namespaced subdirectories. The first EXISTING exact
   #                     candidate stays first. Split Minitest files join a
   #                     Minitest match. A matched spec is left as that one file.
+  #   * test_given_as_source? — whether a positional argument is a test file
+  #                     by these same names, given as a source by mistake
+  #                     after `--test` (#293).
   #
   # Independently unit-testable: every method is pure in/out over the
   # filesystem, so the pairing contract is exercised with plain fixtures, no
@@ -144,6 +147,64 @@ module Mutineer
       prefer == "rspec" ? rspec + minitest : minitest + rspec
     end
 
+    # Basenames that pair as tests in {candidates}: `*_test.rb`, `*_spec.rb`
+    # and Minitest's `test_*.rb`, but not its `test_helper.rb` support file.
+    TEST_NAME = /\A(?!test_helper\.rb\z)(?:.+_(?:test|spec)|test_.+)\.rb\z/
+
+    # Whether the `run` guard rejects a positional argument as a test file
+    # given as a source (#293). Segments are read from the path relative to
+    # the root, so a `test/` folder above the project never counts. A
+    # `*_test.rb` / `*_spec.rb` path is flagged when it has a `test/` or
+    # `spec/` segment (the guard's original rule), or when it sits in the same
+    # directory as a given test, which catches root-level tests. A
+    # `test_*.rb` path is flagged only under the
+    # project's top-level `test/` or `spec/`, because real sources use the
+    # prefix (`lib/mutineer/test_runners.rb`, `lib/foo/test/test_app.rb`). A
+    # source whose own test (`<stem>_test.rb`, `test_<stem>.rb`,
+    # `<stem>_spec.rb`, or a split `<stem>_*_test.rb` not claimed by a longer
+    # source on disk) sits beside it in the test set is not flagged. Paths
+    # compare relative to the root, as in
+    # {expand_sources} (the root's real path counts too, for macOS `/var` vs
+    # `/private/var`), so `./a_test.rb` and `a_test.rb` match. No file content
+    # is read.
+    #
+    # @param path [String] positional argument as typed.
+    # @param project_root [String] repository root for relative expansion.
+    # @param tests [Array<String>] the explicit test files.
+    # @return [Boolean] true when the argument looks like a misplaced test.
+    def test_given_as_source?(path, project_root:, tests:)
+      name = File.basename(path)
+      return false unless name.match?(TEST_NAME)
+
+      root = File.expand_path(project_root)
+      roots = [root, ProjectPath.root_real(root)].uniq
+      relative = lambda do |p|
+        abs = File.expand_path(p, root)
+        root_relative(abs, roots) || abs
+      end
+      rel = relative.call(path)
+      # Outside the root, read segments from a relative path as typed
+      # (`../test/b_test.rb`) and not from an absolute one, so a `test/`
+      # folder above the root never counts.
+      segments = root_relative(File.expand_path(path, root), roots)
+      segments ||= path.start_with?(File::SEPARATOR) ? "" : path
+      return segments.match?(%r{\A(test|spec)/}) unless name.match?(/_(test|spec)\.rb\z/)
+      return true if segments.match?(%r{(\A|/)(test|spec)/})
+
+      dir = File.dirname(rel)
+      beside = Array(tests).map(&relative)
+                           .select { |t| File.dirname(t) == dir }
+                           .map { |t| File.basename(t) }
+      stem = File.basename(name, ".rb")
+      own = ["test_#{stem}.rb", "#{stem}_spec.rb"]
+      base = rel.delete_suffix(".rb")
+      return false if beside.any? do |t|
+        own.include?(t) || (longer_owns_entry?(t, stem) && !claimed_by_longer_source?(root, base, t))
+      end
+
+      beside.any?
+    end
+
     # `<basename>_*_test.rb` files in each mirrored test directory (#87). The
     # exact `<basename>_test.rb` name is not included. `lib/` sources also look
     # under `test/lib/`. Names are matched as text, not as a glob, so a basename

data/lib/mutineer/project.rb

@@ -17,14 +17,151 @@ module Mutineer
     def self.discover(paths, only: nil)
       subjects = Array(paths).flat_map do |path|
         result = Parser.parse_file(path)
-        visitor = SubjectVisitor.new(path)
+        visitor = SubjectVisitor.new(path, plain_path_calls(result.value))
         visitor.visit(result.value)
         visitor.promote_module_functions!
+        exclude_ambiguous_hook_defs!(visitor.subjects, result.value)
         visitor.subjects
       end
       only ? subjects.select { |s| s.qualified_name == only } : subjects
     end
 
+    # Keeps hook defs unplaceable when the raw AST can define another method
+    # with the same name and source line. Count all defs, including bodies that
+    # SubjectVisitor does not select, and Ruby's explicit method creators (see
+    # {.created_method_locations}). Indirect callable bodies may come from any
+    # block or lambda in this file, including a stored hook block. An unknown
+    # creator name blocks only those possible source lines. Instance and
+    # singleton definitions can both reach singleton-class hosts, so their
+    # shared name and line are ambiguous too. Run before `only` so selecting
+    # one subject cannot hide a collision.
+    #
+    # @param subjects [Array<Mutineer::Subject>] subjects from one source file.
+    # @param program [Prism::ProgramNode] the complete parsed file.
+    # @return [void]
+    def self.exclude_ambiguous_hook_defs!(subjects, program)
+      return unless subjects.any?(&:reload_hook_call)
+
+      counts = Hash.new(0)
+      body_lines = Set.new
+      indirect_names = Set.new
+      nodes = [program]
+      while (node = nodes.pop)
+        nodes.concat(node.compact_child_nodes)
+        if node.is_a?(Prism::LambdaNode) || node.is_a?(Prism::BlockNode)
+          body_lines << node.location.start_line
+        end
+        location = if node.is_a?(Prism::DefNode)
+                     [node.location.start_line, [node.name]]
+                   elsif node.is_a?(Prism::CallNode)
+                     created_method_locations(node)
+                   end
+        next unless location
+
+        line, names = location
+        if line
+          names.each { |name| counts[[line, name]] += 1 }
+        else
+          names.each { |name| indirect_names << name }
+        end
+      end
+      indirect_names.each { |name| body_lines.each { |line| counts[[line, name]] += 1 } }
+      subjects.each do |subject|
+        line = subject.def_node.location.start_line
+        subject.reload_hook_call = nil if counts[[line, subject.name]] > 1 || counts[[line, nil]].positive?
+      end
+    end
+    private_class_method :exclude_ambiguous_hook_defs!
+
+    # The source line and names Ruby assigns to explicit method creators. A
+    # block-defined method starts at the block opening and a literal lambda at
+    # its arrow. A positional callable takes precedence over a supplied block.
+    # Other positional bodies and block passes have an indirect source: the
+    # caller checks possible block/lambda lines instead of the call line.
+    # An attribute method starts at the message token, not its receiver line.
+    # Literal symbol and string names are exact. A dynamic name, splat, or attr
+    # writer flag may name any method on that line, represented by nil.
+    #
+    # @param node [Prism::CallNode] call to inspect.
+    # @return [Array, nil] source line and names (a nil line means an indirect
+    #   callable body), or nil for a call outside this built-in family.
+    def self.created_method_locations(node)
+      arguments = node.arguments&.arguments || []
+      case node.name
+      when :define_method, :define_singleton_method
+        body = arguments[1] || node.block
+        body = body.expression if body.is_a?(Prism::BlockArgumentNode)
+        line = body.location.start_line if body.is_a?(Prism::BlockNode) || body.is_a?(Prism::LambdaNode)
+        return [line, [literal_method_name(arguments.first)]]
+      when :attr_reader, :attr_writer, :attr_accessor, :attr
+        mode = { attr_reader: :reader, attr_writer: :writer, attr_accessor: :both, attr: :reader }.fetch(node.name)
+        if node.name == :attr && arguments.size == 2 &&
+           (arguments.last.is_a?(Prism::TrueNode) || arguments.last.is_a?(Prism::FalseNode))
+          mode = arguments.last.is_a?(Prism::TrueNode) ? :both : :reader
+          arguments = arguments.first(1)
+        end
+        names = arguments.flat_map do |argument|
+          name = literal_method_name(argument)
+          next [nil] unless name
+
+          case mode
+          when :reader then [name]
+          when :writer then [:"#{name}="]
+          else [name, :"#{name}="]
+          end
+        end
+        [node.message_loc.start_line, names]
+      end
+    end
+    private_class_method :created_method_locations
+
+    # A literal method name, or nil when it depends on a runtime value.
+    #
+    # @param node [Prism::Node, nil] name argument.
+    # @return [Symbol, nil]
+    def self.literal_method_name(node)
+      node.unescaped.to_sym if node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+    end
+    private_class_method :literal_method_name
+
+    # The call statements that run each time the file loads, in order: each one
+    # sits in the file's top-level statements or in a `module` or `class` body
+    # reached only through such statements. A call under any `if`, `unless`,
+    # `case`, `&&`, `rescue` or loop, an assignment, an argument, a def or a block
+    # is not on this path. A file with a `return` outside any def or block may
+    # stop before a call, so it has none (#297).
+    #
+    # @param program [Prism::ProgramNode] the parsed file.
+    # @return [Set<Prism::CallNode>] compared by identity.
+    def self.plain_path_calls(program)
+      calls = Set.new.compare_by_identity
+      return calls if top_level_return?(program)
+
+      bodies = [program.statements]
+      while (body = bodies.pop)
+        body.body.each do |node|
+          calls << node if node.is_a?(Prism::CallNode)
+          bodies << node.body if (node.is_a?(Prism::ModuleNode) || node.is_a?(Prism::ClassNode)) &&
+                                 node.body.is_a?(Prism::StatementsNode)
+        end
+      end
+      calls
+    end
+    private_class_method :plain_path_calls
+
+    # True when the node holds a `return` that is not inside a def, a block or a
+    # lambda, so loading the file can stop early.
+    #
+    # @param node [Prism::Node] node to search.
+    # @return [Boolean]
+    def self.top_level_return?(node)
+      return true if node.is_a?(Prism::ReturnNode)
+      return false if node.is_a?(Prism::DefNode) || node.is_a?(Prism::BlockNode) || node.is_a?(Prism::LambdaNode)
+
+      node.compact_child_nodes.any? { |child| top_level_return?(child) }
+    end
+    private_class_method :top_level_return?
+
     # Walks an AST, maintaining a namespace stack, emitting Subjects.
     # Nested inside Project to signal its private role.
     class SubjectVisitor < Prism::Visitor
@@ -34,6 +171,9 @@ module Mutineer
       # ActiveSupport::Concern calls whose block another module or class runs (see {#concern_block}).
       CONCERN_BLOCKS = %i[class_methods included prepended].freeze
 
+      # Calls whose first argument names a method they reach (see {#placeable_hook}).
+      NAME_TAKERS = %i[method instance_method send public_send __send__].freeze
+
       # A constant name, or a path of them; Ruby allows Unicode in both.
       CONSTANT_PATH = /\A[[:upper:]][[:word:]]*(?:::[[:upper:]][[:word:]]*)*\z/
 
@@ -61,8 +201,11 @@ module Mutineer
       # Builds a subject visitor.
       #
       # @param file [String] source file path being visited.
-      def initialize(file)
+      # @param plain_calls [Set<Prism::CallNode>] the file's call statements on a
+      #   plain path (see {Project.plain_path_calls}); only these hook calls can be placed.
+      def initialize(file, plain_calls = Set.new)
         @file = file
+        @plain_calls = plain_calls
         @namespace_stack = []
         @lexical_stack = [] # class/module names as written, `::X` kept (#145)
         @subjects = []
@@ -83,6 +226,9 @@ module Mutineer
         @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?})
+        @enclosing_subject = nil     # the subject of the def being visited, for a nested def (#290)
+        @hook_call = nil             # that block's call node, when reload can place its defs (see {#placeable_hook})
+        @hook_uses = Set.new         # the names that block calls outside its def bodies
         super()
       end
 
@@ -96,7 +242,12 @@ module Mutineer
         return if @module_function_names.empty?
 
         named = @module_function_names.to_set
-        @subjects.each_with_index { |s, i| s.singleton = true if named.include?([@subject_keys[i], s.name]) }
+        @subjects.each_with_index do |s, i|
+          next unless named.include?([@subject_keys[i], s.name])
+
+          s.singleton = true
+          s.reload_hook_call = nil # a module function has a second, private copy no hook def placement makes
+        end
       end
 
       # Visits class nodes and tracks namespace nesting.
@@ -156,6 +307,7 @@ module Mutineer
           hook = hook_block?(node)
           return preserving_scope do
             @hook_block ||= hook
+            @hook_call, @hook_uses = placeable_hook(node) if hook
             @owner_unknown = true
             super
           end
@@ -244,25 +396,29 @@ module Mutineer
       # @param node [Prism::DefNode] method definition node.
       # @return [void]
       def visit_def_node(node)
-        @subjects << Subject.new(
+        subject = Subject.new(
           file: @file,
           namespace: (@block_namespace || @namespace_stack).dup,
           lexical: @lexical_stack.dup,
           block_owner: @block_owner,
           owner_unknown: @owner_unknown,
           hook_block: @hook_block,
+          reload_hook_call: reload_hook_call_for(node),
           name: node.name,
           singleton: !node.receiver.nil? || @singleton_depth.positive? || @module_function_active,
-          def_node: node
+          def_node: node,
+          enclosing_subject: @enclosing_subject
         )
+        @subjects << subject
         @subject_keys << module_key
         saved_active = @module_function_active
-        saved_self = [@self_unknown, @self_scope]
+        saved_self = [@self_unknown, @self_scope, @enclosing_subject]
         @self_unknown = true # `self` in a method body is the receiver it is called on
         @self_scope = node
+        @enclosing_subject = subject
         super
         @module_function_active = saved_active # a visibility call in a method body runs only when it is called
-        @self_unknown, @self_scope = saved_self
+        @self_unknown, @self_scope, @enclosing_subject = saved_self
       end
 
       private
@@ -347,7 +503,7 @@ module Mutineer
             end
           @lexical_stack += [root ? "::#{name}" : name]
           @module_function_active = false
-          @block_owner = @block_namespace = nil
+          @block_owner = @block_namespace = @hook_call = nil
           # redefine reopens the lexical chain, which does not pass through the block's `self`
           @namespace_unknown = @owner_unknown = in_singleton || self_in_block || @namespace_unknown
           @singleton_depth = 0
@@ -361,7 +517,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 @hook_block].freeze
+                       @self_unknown @self_scope @singleton_uncertain @hook_block @hook_call @hook_uses].freeze
 
       # Runs the block and then restores every {SCOPE_STATE} variable, so a
       # nested body's state never leaks out of it.
@@ -512,9 +668,10 @@ module Mutineer
       # 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`.
+      # runs it in a class that already has the concern (#256). Reload can still
+      # place a def that sits directly in such a block (see {#placeable_hook} and
+      # {#reload_hook_call_for}, #297); anything else the block defines, a nested
+      # class or a builder block included, stays as the original wrote it.
       #
       # @param node [Prism::CallNode] a call {#concern_block} sorted as a concern block.
       # @return [Boolean]
@@ -522,6 +679,63 @@ module Mutineer
         %i[included prepended].include?(node.name) && @concern_modules.include?(module_key)
       end
 
+      # The hook call and the names its block calls outside its def bodies, when
+      # reload can place the block's defs (#297), else nil and an empty set. The
+      # call must be on a plain path ({Project.plain_path_calls}), so the statement
+      # the mutant file adds before it runs exactly when the call runs. An alias in
+      # the block keeps the original body, so a block with any `alias` or
+      # `alias_method` places nothing. The names come from bare calls, `self.`
+      # calls and the name given to `method`, `instance_method`, `send`,
+      # `public_send` or `__send__`, in every nested block and lambda too:
+      # discovery cannot tell a block that runs at once from one that runs
+      # later. A name such a call computes at runtime places nothing.
+      #
+      # @param node [Prism::CallNode] the hook call.
+      # @return [Array(Prism::CallNode, Set<Symbol>), Array(nil, Set<Symbol>)]
+      def placeable_hook(node)
+        uses = Set.new
+        return [nil, uses] unless @plain_calls.include?(node)
+
+        nodes = [node.block.body].compact
+        while (current = nodes.pop)
+          next if current.is_a?(Prism::DefNode)
+          return [nil, Set.new] if current.is_a?(Prism::AliasMethodNode)
+
+          if current.is_a?(Prism::CallNode) && (current.receiver.nil? || current.receiver.is_a?(Prism::SelfNode))
+            return [nil, Set.new] if current.name == :alias_method
+
+            uses << current.name
+            if NAME_TAKERS.include?(current.name) && (name_arg = current.arguments&.arguments&.first)
+              # A runtime name may be any def in the block.
+              return [nil, Set.new] unless name_arg.is_a?(Prism::SymbolNode) || name_arg.is_a?(Prism::StringNode)
+
+              uses << name_arg.unescaped.to_sym
+            end
+          end
+          nodes.concat(current.compact_child_nodes)
+        end
+        [node, uses]
+      end
+
+      # The hook call of the block this def sits in directly, when reload can
+      # place the def (#297), else nil. The def must be in the block itself, or
+      # in its `class << self` without a receiver: not in a def, a nested class
+      # or module, or another block. `module_function` gives the def a second,
+      # private copy, and a name the block itself uses kept the original's
+      # result, so neither is placeable. An explicit receiver other than `self`
+      # can be bound only inside the hook, which the extracted def does not keep.
+      #
+      # @param node [Prism::DefNode] the def being recorded.
+      # @return [Prism::CallNode, nil]
+      def reload_hook_call_for(node)
+        return unless @hook_call && @self_scope.equal?(@hook_call.block) && !@module_function_active
+        return if node.receiver && !node.receiver.is_a?(Prism::SelfNode)
+        return if @singleton_depth > 1 || (@singleton_depth == 1 && node.receiver)
+        return if @hook_uses.include?(node.name)
+
+        @hook_call
+      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.