mutineer 1.3.0 → 1.5.0

data/lib/mutineer/mutators/operator_assignment.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Operator-assignment mutator (Tier-2).
+    #
+    # Swaps the operator of a compound assignment, one mutation per
+    # occurrence: `t += x` -> `t -= x`. Prism parses `t += x` as its own
+    # node, not as a CallNode, so the arithmetic mutator never sees it.
+    #
+    # The mapping is the same as for arithmetic. Other compound operators
+    # (`||=`, `&&=`, `|=`, `<<=` and the rest) are not changed.
+    class OperatorAssignment < Base
+      # Token replacements for compound arithmetic operators.
+      REPLACEMENTS = {
+        :+ => "-=", :- => "+=", :* => "/=", :/ => "*=", :% => "*=", :** => "*="
+      }.freeze
+
+      # Visits `t += x`.
+      #
+      # @param node [Prism::LocalVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_local_variable_operator_write_node(node)
+        emit(node)
+        super # the value can hold its own compound assignment
+      end
+
+      # Visits `@t += x`.
+      #
+      # @param node [Prism::InstanceVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_instance_variable_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `@@t += x`.
+      #
+      # @param node [Prism::ClassVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_class_variable_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `$t += x`.
+      #
+      # @param node [Prism::GlobalVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_global_variable_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `T += x`.
+      #
+      # @param node [Prism::ConstantOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_constant_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `A::T += x` and `::T += x`.
+      #
+      # @param node [Prism::ConstantPathOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_constant_path_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a.b += x` and `a&.b += x`.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a[i] += x`.
+      #
+      # @param node [Prism::IndexOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_index_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      private
+
+      # Emits a mutation when the node's operator has a replacement.
+      #
+      # @param node [Prism::Node] a node with `binary_operator` and `binary_operator_loc`.
+      # @return [void]
+      def emit(node)
+        replacement = REPLACEMENTS[node.binary_operator]
+        return unless replacement
+
+        loc = node.binary_operator_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: replacement,
+          operator: :operator_assignment
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/return_nil.rb

@@ -16,11 +16,12 @@ module Mutineer
       def mutations_for(subject, source)
         @source = source
         @mutations = []
-        body = subject.def_node.body
-        if body
-          body.accept(self)       # rule 1 (explicit return nodes in this body)
-          final_expression_nil(body) # rule 2 (method's final expression)
+        @body = subject.def_node.body
+        if @body
+          @body.accept(self)       # rule 1 (explicit return nodes in this body)
+          final_expression_nil(@body) # rule 2 (method's final expression)
         end
+        drop_dangling_heredocs
         @mutations
       end
 
@@ -39,13 +40,6 @@ module Mutineer
         super
       end
 
-      # Nested method definitions are discovered as their own subjects; do not
-      # recurse into them (prevents double-counting their statements).
-      #
-      # @param node [Prism::DefNode] nested definition node.
-      # @return [void]
-      def visit_def_node(node); end
-
       private
 
       # Mutates a method's final expression to nil when eligible.

data/lib/mutineer/mutators/string_literal.rb

@@ -15,7 +15,7 @@ module Mutineer
       # @param node [Prism::StringNode] node to inspect.
       # @return [void]
       def visit_string_node(node)
-        # ponytail: only plain "..." / '...' quotes. opening is nil for
+        # Only plain "..." / '...' quotes. opening is nil for
         # interpolation parts and %w[] elements; heredocs/%-literals use a
         # different opening token. Skipping them keeps mutants re-parseable.
         if %w[" '].include?(node.opening)

data/lib/mutineer/pairing.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
+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:
-  #   * expand_sources — a directory argument becomes its sorted **/*.rb files.
-  #   * infer_test     — a source's test file by convention (app/ and lib/
-  #                     sources map to test/.../_test.rb, test/.../test_*.rb
-  #                     or spec/.../_spec.rb), preserving namespaced
-  #                     subdirectories. First EXISTING candidate wins.
+  #   * 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/
+  #                     sources map to test/.../_test.rb, test/.../<name>_*_test.rb,
+  #                     test/.../test_*.rb or spec/.../_spec.rb), preserving
+  #                     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.
   #
   # Independently unit-testable: every method is pure in/out over the
   # filesystem, so the pairing contract is exercised with plain fixtures, no
@@ -17,37 +22,88 @@ module Mutineer
 
     # Expand each positional source: a directory -> its sorted **/*.rb files
     # (relative to project_root); a file (or glob, or anything non-directory)
-    # -> itself. Flattened, deduped, order-stable.
+    # -> its path relative to project_root, so `./lib/x.rb` and an absolute
+    # path pair like `lib/x.rb` (#104). A missing file, or one outside the
+    # root, stays as typed. Flattened, deduped, order-stable.
     #
     # @param args [Array<String>] source paths or directories.
     # @param project_root [String] repository root for relative expansion.
     # @return [Array<String>] flattened, deduped source file list.
     def expand_sources(args, project_root:)
       root = File.expand_path(project_root)
+      # The root as typed and as its real path (macOS `/var` vs `/private/var`),
+      # resolved once for every file below.
+      roots = [root, ProjectPath.root_real(root)].uniq
       Array(args).flat_map do |arg|
         abs = File.expand_path(arg, root)
         if File.directory?(abs)
-          Dir.glob(File.join(abs, "**", "*.rb")).sort.map { |f| f.delete_prefix("#{root}/") }
+          Dir.glob(File.join(abs, "**", "*.rb")).sort.map { |f| existing_relative(f, roots) || f }
         else
-          [arg]
+          # `..` resolves as text, as FileSwap and the daemon already read it.
+          [(existing_relative(abs, roots) if File.exist?(abs)) || arg]
         end
       end.uniq
     end
 
-    # The first EXISTING candidate test path for a source (relative to
-    # project_root), or nil. `prefer` is the resolved framework ("minitest" |
-    # "rspec"): its candidates are tried first, the other framework's as
-    # fallback, so a minitest default still finds a spec and vice-versa.
+    # An existing file's root-relative path, or nil outside the root. Tries the
+    # path as given, then with its directory resolved, so a path typed through
+    # a symlinked parent (or macOS `/var` under a `/private/var` root) matches.
+    # The file's own name is kept, so a symlinked file is not renamed.
+    #
+    # @param abs [String] expanded absolute path of an existing file.
+    # @param roots [Array<String>] the project root, expanded and real.
+    # @return [String, nil] root-relative path, or nil outside the root.
+    def existing_relative(abs, roots)
+      root_relative(abs, roots) ||
+        root_relative(File.join(File.realpath(File.dirname(abs)), File.basename(abs)), roots)
+    end
+
+    # `abs` relative to the first of `roots` it is under, or nil. Text only: a
+    # symlinked source keeps its own name (realpath would rename it to its
+    # target and pair the wrong test). `roots` holds the root's real path too,
+    # so the macOS `/var` vs `/private/var` alias still matches.
+    #
+    # @param abs [String] expanded absolute path.
+    # @param roots [Array<String>] the project root, expanded and real.
+    # @return [String, nil] root-relative path, or nil outside the root.
+    def root_relative(abs, roots)
+      roots.each do |r|
+        prefix = r.end_with?("/") ? r : "#{r}/"
+        return abs.delete_prefix(prefix) if abs.start_with?(prefix)
+      end
+      nil
+    end
+
+    # The first test path {#infer_tests} would run for a source, or nil.
+    # `prefer` is the resolved framework ("minitest" | "rspec"): its candidates
+    # are tried first, the other framework's as fallback, so a minitest default
+    # still finds a spec and vice-versa.
     #
     # @param source_rel [String] relative source path.
     # @param project_root [String] repository root for existence checks.
     # @param prefer [String] preferred framework name.
     # @return [String, nil] existing test path or nil.
     def infer_test(source_rel, project_root:, prefer: "minitest")
+      infer_tests(source_rel, project_root: project_root, prefer: prefer).first
+    end
+
+    # Every test file convention pairs with a source. The first existing exact
+    # candidate from {#candidates} stays first. Each `<basename>_*_test.rb` in
+    # the mirrored test directory is added after it (#87). A spec that the exact
+    # rules already found is left alone: split Minitest names do not join it
+    # and do not replace it.
+    #
+    # @param source_rel [String] relative source path.
+    # @param project_root [String] repository root for existence checks.
+    # @param prefer [String] preferred framework name.
+    # @return [Array<String>] existing test paths, exact candidate first.
+    def infer_tests(source_rel, project_root:, prefer: "minitest")
       base, lib = logical_path(source_rel)
-      candidates(base, lib, prefer).find do |rel|
-        File.exist?(File.expand_path(rel, project_root))
-      end
+      root = File.expand_path(project_root)
+      exact = candidates(base, lib, prefer).find { |rel| File.exist?(File.expand_path(rel, root)) }
+      return [exact] if exact&.end_with?("_spec.rb")
+
+      ([exact] + split_test_files(base, lib, root)).compact.uniq
     end
 
     # Strip the source root to a logical path (no ".rb") and flag lib/
@@ -87,5 +143,156 @@ module Mutineer
       rspec << "spec/lib/#{base}_spec.rb" if lib
       prefer == "rspec" ? rspec + minitest : minitest + rspec
     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
+    # that contains `*` stays literal. `test/` comes before `test/lib/`, and
+    # each directory is sorted.
+    #
+    # @param base [String] logical source path without extension.
+    # @param lib [Boolean] whether the source originated from lib/.
+    # @param root [String] expanded project root.
+    # @return [Array<String>] relative split-test paths.
+    def split_test_files(base, lib, root)
+      name = File.basename(base)
+      dirs = [mirror_dir("test", base)]
+      dirs << mirror_dir("test/lib", base) if lib
+      dirs.flat_map { |dir| split_tests_in(root, dir, name, base) }
+    end
+
+    # Relative test directory for a logical source path. A source with no
+    # subdirectory (`calc`) maps to `prefix` itself, not `prefix/.`.
+    #
+    # @param prefix [String] `test` or `test/lib`.
+    # @param base [String] logical source path without extension.
+    # @return [String] relative directory.
+    def mirror_dir(prefix, base)
+      dir = File.dirname(base)
+      dir == "." ? prefix : File.join(prefix, dir)
+    end
+
+    # Split test files directly inside `dir_rel` (not in subdirectories).
+    #
+    # @param root [String] expanded project root.
+    # @param dir_rel [String] relative directory.
+    # @param name [String] source basename without extension.
+    # @param base [String] logical source path without extension.
+    # @return [Array<String>] sorted relative paths.
+    def split_tests_in(root, dir_rel, name, base)
+      root_abs = File.expand_path(root)
+      dir_abs = File.expand_path(dir_rel, root_abs)
+      return [] unless inside_project?(dir_abs, root_abs)
+      return [] unless File.directory?(dir_abs)
+
+      Dir.children(dir_abs).filter_map do |entry|
+        next unless split_entry?(entry, name)
+        next unless File.file?(File.join(dir_abs, entry))
+        next if claimed_by_longer_source?(root, base, entry, dir_rel)
+
+        File.join(dir_rel, entry)
+      end.sort
+    end
+
+    # True when `dir_abs` is the project root or a directory inside it.
+    # A source path such as `../../evil.rb` must not list tests outside the project.
+    #
+    # @param dir_abs [String] expanded directory.
+    # @param root_abs [String] expanded project root.
+    # @return [Boolean]
+    def inside_project?(dir_abs, root_abs)
+      prefix = root_abs == File::SEPARATOR ? File::SEPARATOR : "#{root_abs}#{File::SEPARATOR}"
+      dir_abs == root_abs || dir_abs.start_with?(prefix)
+    end
+
+    # True when `entry` is `<name>_<piece>_test.rb` and not the exact
+    # `<name>_test.rb` file.
+    #
+    # @param entry [String] test file basename.
+    # @param name [String] source basename without extension.
+    # @return [Boolean]
+    def split_entry?(entry, name)
+      return false unless entry.end_with?("_test.rb")
+
+      rest = entry.delete_prefix("#{name}_")
+      rest != entry && rest.match?(/\A.+_test\.rb\z/)
+    end
+
+    # True when a longer source file on disk owns this split test. `user.rb`
+    # does not take `user_session_test.rb` when `user_session.rb` exists in the
+    # same directory, under `app/`, or under `lib/`. An intermediate file
+    # counts: `bar_upsert.rb` owns `bar_upsert_guards_test.rb`, so `bar.rb`
+    # does not.
+    #
+    # @param root [String] expanded project root.
+    # @param base [String] logical source path without extension.
+    # @param entry [String] test file basename.
+    # @param scanned_dir [String, nil] relative test directory being scanned.
+    #   When set, a longer source claims the file only if that source searches
+    #   this directory. An `app/` source does not take a `test/lib/` file.
+    # @return [Boolean]
+    def claimed_by_longer_source?(root, base, entry, scanned_dir = nil)
+      name = File.basename(base)
+      stem = entry.sub(/_test\.rb\z/, "")
+      return false unless stem.start_with?("#{name}_")
+
+      rest = stem.delete_prefix("#{name}_")
+      return false if rest.empty?
+
+      dir = File.dirname(base)
+      parts = rest.split("_", -1)
+      (1..parts.length).any? do |i|
+        longer = "#{name}_#{parts.first(i).join("_")}"
+        next false unless longer_owns_entry?(entry, longer)
+
+        longer_source_exists?(root, dir, longer, scanned_dir)
+      end
+    end
+
+    # True when `entry` is the exact test, or a split test with a non-empty
+    # piece, for `stem`. `user_session__test.rb` is neither for
+    # `user_session`, so that source does not take it from `user.rb`.
+    #
+    # @param entry [String] test file basename.
+    # @param stem [String] longer source basename without extension.
+    # @return [Boolean]
+    def longer_owns_entry?(entry, stem)
+      entry == "#{stem}_test.rb" || split_entry?(entry, stem)
+    end
+
+    # True when a longer source file exists beside this logical path.
+    # The logical directory itself is checked, so `src/user_session.rb` owns
+    # `test/src/user_session_test.rb`. `app/` and `lib/` are checked too, so an
+    # `app/` source still yields the name to a `lib/` sibling and the reverse.
+    #
+    # @param root [String] expanded project root.
+    # @param dir [String] logical directory, or `.` when the source has none.
+    # @param stem [String] longer source basename without extension.
+    # @param scanned_dir [String, nil] relative test directory being scanned.
+    # @return [Boolean]
+    def longer_source_exists?(root, dir, stem, scanned_dir = nil)
+      file = "#{stem}.rb"
+      folders = [dir == "." ? nil : dir]
+      %w[app lib].each { |prefix| folders << (dir == "." ? prefix : File.join(prefix, dir)) }
+      folders.uniq.any? do |folder|
+        rel = folder ? File.join(folder, file) : file
+        next false unless File.file?(File.join(root, rel))
+        next false if scanned_dir && !source_searches_dir?(rel, scanned_dir)
+
+        true
+      end
+    end
+
+    # True when pairing this source looks in `scanned_dir`.
+    #
+    # @param source_rel [String] project-relative source path.
+    # @param scanned_dir [String] relative test directory.
+    # @return [Boolean]
+    def source_searches_dir?(source_rel, scanned_dir)
+      base, lib = logical_path(source_rel)
+      dirs = [mirror_dir("test", base)]
+      dirs << mirror_dir("test/lib", base) if lib
+      dirs.include?(scanned_dir)
+    end
   end
 end

data/lib/mutineer/parser.rb

@@ -10,9 +10,9 @@ module Mutineer
 
   # Thin boundary around Prism.
   #
-  # Both methods return a Prism::ParseResult so all callers use result.value,
-  # result.source.source (raw bytes), and result.errors uniformly. No wrapping
-  # struct.
+  # The parse methods return a Prism::ParseResult so all callers use
+  # result.value, result.source.source (raw bytes), and result.errors
+  # uniformly. No wrapping struct.
   class Parser
     # Parses a file with Prism.
     #
@@ -32,5 +32,14 @@ module Mutineer
     def self.parse_string(source)
       Prism.parse(source)
     end
+
+    # The comments of source text, without building its syntax tree: a few
+    # times cheaper than {.parse_string} for a caller that needs only these.
+    #
+    # @param source [String] source text.
+    # @return [Array<Prism::Comment>] its comments, in source order.
+    def self.comments(source)
+      Prism.parse_comments(source)
+    end
   end
 end

data/lib/mutineer/project.rb

@@ -82,6 +82,9 @@ module Mutineer
       # @param node [Prism::CallNode] call node.
       # @return [void]
       def visit_call_node(node)
+        if %i[public private protected].include?(node.name) && node.receiver.nil? && node.arguments.nil?
+          @module_function_active = false # without arguments, Ruby goes back to instance methods
+        end
         if node.name == :module_function && node.receiver.nil?
           args = node.arguments&.arguments || []
           if args.empty?
@@ -109,7 +112,9 @@ module Mutineer
         return unless node.expression.is_a?(Prism::SelfNode)
 
         @singleton_depth += 1
+        saved_active = @module_function_active
         super
+        @module_function_active = saved_active # a visibility call in here is not the module body's
         @singleton_depth -= 1
       end
 
@@ -126,7 +131,9 @@ module Mutineer
           singleton: !node.receiver.nil? || @singleton_depth.positive? || @module_function_active,
           def_node: node
         )
+        saved_active = @module_function_active
         super
+        @module_function_active = saved_active # a visibility call in a method body runs only when it is called
       end
 
       private

data/lib/mutineer/rails_worker_db.rb

@@ -65,7 +65,7 @@ module Mutineer
       unless adapter.start_with?("sqlite")
         raise NotImplementedError,
               "worker-DB isolation currently provisions SQLite only (got adapter #{adapter.inspect}); " \
-              "Postgres per-worker provisioning is not yet supported. Use a SQLite test DB, or drop --jobs."
+              "Postgres per-worker provisioning is not yet supported. Use a SQLite test DB with --daemon, or drop --daemon to run serially."
       end
 
       per_worker_config(hash, worker)