polyrun 2.2.3 → 2.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65f2008623ad5bcf9289da8ffb3db95cf07d8261d349978b96ca463b0ff37ea3
-  data.tar.gz: a1fabab4fe6cc0f571b09d8f8a73559866730d6a76a0bc09b48f4a0e0631a724
+  metadata.gz: 6364a918386209ff30b2c12280f3a37a0cb70de54a83f1f07606c2c526ac773c
+  data.tar.gz: 8d75d162af33d721f864cf8a4002d98f57e53d24db55dc607dad82e94f5416f7
 SHA512:
-  metadata.gz: eb24b21418a3804b868f62f72f1d8462b15f4b7ab0a9901e82789fdb0c7eb04a73ece7bd437ae10acc8c4edbffd53e64ae9e648e09376e6d9d7df2789b42be78
-  data.tar.gz: f0dd0a2b341c81ce8ea3f10358e06f205a0f7329d5695eb82e49a97e067133fe5b665b444c1b57236740a0e354b9945658f2e1351e54730a358583cc411641fb
+  metadata.gz: e92439850018abacae0f1041315b213f4624abc78e49b3d4ca53d53129428790961b1d77b8a923d882e0fe0c9157c14c125ab13bbdf34db52c86c82082917104
+  data.tar.gz: 6d64c292b054ffd8cf95a47bda1fa3253284af76e98d8d9fc32631b389e51e9acbf2b3ad6c0e64e19f471847fba17b00b706ef1d4d8c549414abea9be4a9806a

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 2.2.5 (2026-09-24)
+
+- Fix bare `polyrun` suite selection when both `spec/` and `test/` exist: honor `partition.suite`, else infer from `partition.paths_file`, else filesystem auto-detect (RSpec first).
+- Exit 2 when `partition.suite` disagrees with `paths_file`, or when `run-shards` paths infer a different suite than a recognizable command after `--`.
+- Add `parallel-minitest` and `parallel-quick` CLI subcommands (same shape as `parallel-rspec`); they do not run `start` prepare or database bootstrap.
+- Recognize `bin/rails test` and compact `ruby -Itest` in the suite/command mismatch guard; strip `path:line` locators before classifying paths.
+- Skip legacy `spec/spec_paths.txt` when `partition.suite` is `minitest` or `quick`; allow mixed path lists only with suite-agnostic custom runners.
+
+## 2.2.4 (2026-09-04)
+
+- Fix `DEBUG_SQL` / `POLYRUN_DEBUG_SQL` raising `NoMethodError` for `loggable_sql?` when the SQL subscriber runs on an RSpec example group.
+- Add `rfcs/` starter pack: process (RFC 0001), positioning (RFC 0002), and Standards Track design RFCs 0003–0006 for shard layouts, coverage merge, hooks, and partition config.
+
 ## 2.2.3 (2026-08-16)
 
 - Fix `merge-failures` `Encoding::CompatibilityError` when JSONL or RSpec JSON contains UTF-8 and the process locale is US-ASCII; read fragments as UTF-8

data/CODE_OF_CONDUCT.md

@@ -1,31 +1,26 @@
 # Code of Conduct
 
-## Our Pledge
+## Pledge
 
-We pledge to make participation in our community a harassment-free experience for everyone. We operate on principles of mutual respect, privacy, and authentic engagement. We value substantive contributions and clarity on intentions.
+Participation is a harassment-free experience. Treat each other with respect. Keep private context private.
 
-## Our Standards
+## Expected behavior
 
-Examples of behavior that contributes to a positive environment include:
+- Engage with genuine curiosity. Admit uncertainty.
+- Own every line you submit, including generated code.
+- Correct errors politely.
+- Use language that welcomes people and respects identity and privacy.
 
-- Authenticity: Engaging with genuine curiosity and admitting uncertainty rather than feigning knowledge.
-- Responsible Innovation: Taking full responsibility for any content or code contributed, whether manually written or generated by automation tools.
-- Gentle Correction: Responding politely to errors. We view mistakes as opportunities for learning, provided they are addressed with humility.
-- Inclusive Language: Using language that welcomes diverse perspectives and respects the privacy and identity of all participants.
+## Unacceptable behavior
 
-Examples of unacceptable behavior include:
+- Harassment, trolling, or insulting comments, public or private.
+- Using jargon or volume, including automated spam, to silence others.
+- Sharing others' data or personal context without permission.
 
-- Harassment: Public or private harassment, trolling, or insulting comments.
-- Weaponized Complexity: Using jargon or overwhelming volume (including automated spam) to silence others.
-- Publishing Private Information: Sharing others' data or personal context without explicit permission.
+## Automation
 
-## Artificial Intelligence and Automation
-
-In accordance with our commitment to collective awareness:
-
-- Contributors are responsible for the accuracy and security of any AI-generated artifacts they submit.
-- "The AI wrote it" is not a valid excuse for introducing bugs, security vulnerabilities, or bias.
+You remain responsible for bugs, security holes, and bias in generated artifacts you submit.
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@kiskolabs.com. All complaints will be reviewed and investigated promptly and fairly.
+Report abusive or harassing behavior to contact@kiskolabs.com. Reports are reviewed and investigated.

data/CONTRIBUTING.md

@@ -1,29 +1,23 @@
 # Contributing Guidelines
 
-Thank you for your interest in contributing. We value learning over perfection but require rigor and responsibility.
+## Automation authorship
 
-## The Golden Rule of Automation
+You may use AI and automation tools. You remain the author of every line you submit: review, debug, and understand the change.
 
-We welcome the use of AI and automation tools to reduce toil, but you must strictly adhere to the following:
+Keep pull requests small enough to review. Annotate non-obvious logic.
 
-1. You are the Author: You act as the responsible agent for any code you submit. You must review, debug, and understand every line.
-2. Manage Cognitive Load: Do not submit massive, unreviewed automated dumps. Respect the reviewers' time by annotating complex logic.
-3. Security: Never feed project secrets or private context into public AI models.
+Never send project secrets or private context to public models.
 
-## How to Contribute
+## How to contribute
 
-### 1. Reporting Issues
+### Reporting issues
 
-- Verify Accuracy: Before posting, verify your information. Avoid generalizations.
-- Use Structured Inputs: Use issue templates to provide clear goals, constraints, and reproduction steps. This helps us understand the context immediately.
+Verify the facts before filing. Use issue templates for goals, constraints, and reproduction steps.
 
-### 2. Pull Request Process
+### Pull requests
 
-- Scope: Keep PRs focused on a single goal.
-- Context: Explain why the change is necessary. Transparency builds trust.
-- Testing: Run all smoke tests and regression checks locally. We prioritize safety first.
+Keep one pull request to one goal. Explain why the change is needed. Run smoke tests and regression checks locally before opening the request.
 
-### 3. Review Process
+### Review
 
-- We encourage productive friction. Expect questions about your approach.
-- If a reviewer suggests a change, view it as mutual aid, not criticism.
+Reviewers will ask about approach and trade-offs. Treat suggested changes as part of the work.

data/README.md

@@ -2,13 +2,15 @@
 
 Ruby gem for parallel test runs, merged coverage (SimpleCov-compatible JSON to JSON, LCOV, Cobertura, or console output), CI reporting (JUnit, timing), and parallel-test hygiene (fixtures, snapshots, per-shard databases, asset preparation). Ship it as one development dependency: no runtime gem dependencies beyond the standard library and vendored code.
 
+Design changes go through `rfcs/` (RFC 0001).
+
 ## Why?
 
 Running tests in parallel across processes still requires a single merged coverage report, stable shard assignment, isolated databases per worker so rows are not shared, and reliable timing data for cost-based splits—without wiring together many small tools and shell scripts.
 
 Polyrun provides:
 
-- Orchestration: `plan`, `run-shards`, and `parallel-rspec` (run-shards plus merge-coverage), with an optional on-disk queue and constraints for file lists and load balancing. For **GitHub Actions-style matrix sharding** (one job per global shard), use `ci-shard-run -- …` (any test runner) or `ci-shard-rspec`—not `run-shards` / `parallel-rspec`, which fan out N workers on one machine.
+- Orchestration: `plan`, `run-shards`, and `parallel-rspec` / `parallel-minitest` / `parallel-quick` (run-shards plus merge-coverage), with an optional on-disk queue and constraints for file lists and load balancing. Bare `polyrun` (no subcommand) picks the suite from `partition.suite`, else `partition.paths_file`, else filesystem auto-detect. For **GitHub Actions-style matrix sharding** (one job per global shard), use `ci-shard-run -- …` (any test runner) or `ci-shard-rspec`—not `run-shards` / `parallel-*`, which fan out N workers on one machine.
 - Coverage: merge SimpleCov-compatible JSON fragments; emit JSON, LCOV, Cobertura, or console summaries (you can drop separate SimpleCov merge plugins for this path).
 - CI reporting: JUnit XML from RSpec JSON; slow-file reports from merged timing JSON.
 - Parallel hygiene: asset digest markers, SQL snapshots, YAML fixture batches, and DB URL or shard helpers aligned with `POLYRUN_SHARD_*`.
@@ -90,6 +92,8 @@ bin/polyrun build-paths   # write spec/spec_paths.txt from partition.paths_build
 bin/polyrun ci-shard-run -- bundle exec rspec   # CI matrix: shard plan + append paths to the command after --
 bin/polyrun ci-shard-rspec   # same as ci-shard-run -- bundle exec rspec
 bin/polyrun parallel-rspec --workers 5   # run-shards + merge-coverage (default: bundle exec rspec)
+bin/polyrun parallel-minitest --workers 5   # same; default rails test or ruby -I test
+bin/polyrun parallel-quick --workers 5   # same; default bundle exec polyrun quick
 bin/polyrun run-shards --workers 5 --merge-coverage -- bundle exec rspec
 bin/polyrun merge-coverage -i cov1.json -i cov2.json -o merged.json --format json,lcov,cobertura,console
 bin/polyrun env --shard 0 --total 4   # print DATABASE_URL exports from polyrun.yml in cwd

data/SECURITY.md

@@ -2,26 +2,24 @@
 
 ## Reporting a Vulnerability
 
-Do not open a public issue for security vulnerabilities.
-
 Email security details to: security@kiskolabs.com
 
-Include: description, steps to reproduce, potential impact, and suggested fix (if available).
+Send the report only to that address. Include description, steps to reproduce, potential impact, and a suggested fix when you have one.
 
 ### Response Timeline
 
-- We will acknowledge receipt of your report
-- We will provide an initial assessment
-- We will keep you informed of our progress and resolution timeline
+- We will acknowledge receipt of your report.
+- We will provide an initial assessment.
+- We will keep you informed of our progress and resolution timeline.
 
 ### Disclosure Policy
 
-- We will work with you to understand and resolve the issue
-- We will credit you for the discovery (unless you prefer to remain anonymous)
-- We will publish a security advisory after the vulnerability is patched
-- We will coordinate public disclosure with you
+- We will work with you to understand and resolve the issue.
+- We will credit you for the discovery unless you prefer to remain anonymous.
+- We will publish a security advisory after the vulnerability is patched.
+- We will coordinate public disclosure with you.
 
 ## Automation Security
 
-- Context Isolation: It is strictly forbidden to include production credentials, API keys, or Personally Identifiable Information (PII) in prompts sent to third-party LLMs or automation services.
-- Supply Chain: All automated dependencies must be verified.
+- Keep production credentials, API keys, and personal data out of prompts sent to third-party models or automation services.
+- Verify automated dependencies.

data/lib/polyrun/cli/default_run.rb

@@ -7,20 +7,32 @@ module Polyrun
       private
 
       def dispatch_default_parallel!(config_path)
-        suite = Polyrun::Partition::Paths.detect_auto_suite(Dir.pwd)
-        unless suite
-          Polyrun::Log.warn "polyrun: no tests found (spec/**/*_spec.rb, test/**/*_test.rb, or Polyrun quick files). See polyrun help."
+        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
+        pc = cfg.partition
+        code = Polyrun::Partition::PathsBuild.apply!(partition: pc, cwd: Dir.pwd)
+        return code if code != 0
+
+        resolved = Polyrun::Partition::Suite.resolve_default(cwd: Dir.pwd, partition: pc)
+        if resolved[:error]
+          Polyrun::Log.warn "polyrun: #{resolved[:error]}"
           return 2
         end
 
+        suite = resolved[:suite]
         Polyrun::Log.warn "polyrun: default → parallel #{suite} (use `polyrun help` for subcommands)" if @verbose
 
         case suite
         when :rspec
           cmd_start([], config_path)
         when :minitest
+          code = start_bootstrap!(cfg, [], config_path)
+          return code if code != 0
+
           cmd_parallel_minitest([], config_path)
         when :quick
+          code = start_bootstrap!(cfg, [], config_path)
+          return code if code != 0
+
           cmd_parallel_quick([], config_path)
         else
           2

data/lib/polyrun/cli/help.rb

@@ -5,7 +5,7 @@ module Polyrun
         Polyrun::Log.puts <<~HELP
           usage: polyrun [global options] [<command> | <paths...>]
 
-          With no command, runs parallel tests for the detected suite: RSpec under spec/, Minitest under test/, or Polyrun Quick (same discovery as polyrun quick). If the first argument is a known subcommand name, it is dispatched. Otherwise, path-like tokens (optionally with run-shards flags such as --workers) shard those files in parallel; see commands below.
+          With no command, runs parallel tests for the resolved suite: partition.suite when set; else suite inferred from partition.paths_file; else filesystem auto-detect (RSpec under spec/ before Minitest under test/, then Polyrun Quick). If the first argument is a known subcommand name, it is dispatched. Otherwise, path-like tokens (optionally with run-shards flags such as --workers) shard those files in parallel; see commands below.
 
           global:
             -c, --config PATH    polyrun.yml path (or POLYRUN_CONFIG)
@@ -40,7 +40,9 @@ module Polyrun
             merge-coverage       merge SimpleCov JSON fragments (json/lcov/cobertura/console/html/csv/markdown)
             merge-failures       merge per-shard failure JSONL fragments or RSpec JSON files (jsonl/json/csv/markdown)
             run-shards           fan out N parallel OS processes (POLYRUN_SHARD_*; not Ruby threads); optional --merge-coverage / --merge-failures / --merge-spec-quality
-            parallel-rspec       run-shards + merge-coverage (defaults to: bundle exec rspec after --)
+            parallel-rspec       run-shards + merge-coverage (defaults to: bundle exec rspec after --); no start prepare/DB bootstrap
+            parallel-minitest    run-shards + merge-coverage (defaults to: bundle exec rails test or ruby -I test after --); no start prepare/DB bootstrap
+            parallel-quick       run-shards + merge-coverage (defaults to: bundle exec polyrun quick after --); no start prepare/DB bootstrap
             start                parallel-rspec; auto-runs prepare (shell/assets) and db:setup-* when polyrun.yml configures them; legacy script/build_spec_paths.rb if paths_build absent
             ci-shard-run         CI matrix: build-paths + plan for POLYRUN_SHARD_INDEX / POLYRUN_SHARD_TOTAL (or config), then run your command with that shard's paths after --; optional --shard-processes M or --workers M (POLYRUN_SHARD_PROCESSES; not POLYRUN_WORKERS) for N×M jobs × processes on this host
             ci-shard-rspec       same as ci-shard-run -- bundle exec rspec; optional --shard-processes / --workers / -- [rspec-only flags]

data/lib/polyrun/cli/run_shards_command.rb

@@ -40,11 +40,8 @@ module Polyrun
       end
 
       # Same as parallel-rspec but runs +bundle exec rails test+ or +bundle exec ruby -I test+ after +--+.
+      # Does not run +start+ prepare/database bootstrap (use +polyrun start+ or bare +polyrun+ for that).
       def cmd_parallel_minitest(argv, config_path)
-        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
-        code = start_bootstrap!(cfg, argv, config_path)
-        return code if code != 0
-
         sep = argv.index("--")
         combined =
           if sep
@@ -60,11 +57,8 @@ module Polyrun
 
       # Same as parallel-rspec but runs +bundle exec polyrun quick+ after +--+ (one Quick process per shard).
       # Run from the app root with +bundle exec+ so workers resolve the same gem as the parent (same concern as +bundle exec rspec+).
+      # Does not run +start+ prepare/database bootstrap (use +polyrun start+ or bare +polyrun+ for that).
       def cmd_parallel_quick(argv, config_path)
-        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
-        code = start_bootstrap!(cfg, argv, config_path)
-        return code if code != 0
-
         sep = argv.index("--")
         combined =
           if sep

data/lib/polyrun/cli/run_shards_plan_boot_phases.rb

@@ -33,6 +33,9 @@ module Polyrun
         items, paths_source, err = run_shards_resolve_items(o[:paths_file], pc)
         return [err, nil] if err
 
+        err = run_shards_validate_suite_vs_command!(items, cmd)
+        return [err, nil] if err
+
         costs, strategy, err = run_shards_resolve_costs(
           o[:timing_path],
           o[:strategy],

data/lib/polyrun/cli/run_shards_planning.rb

@@ -64,9 +64,18 @@ module Polyrun
           Polyrun::Log.warn "polyrun run-shards: no paths (empty paths file or list)"
           return [nil, nil, 2]
         end
+
         [items, paths_source, nil]
       end
 
+      def run_shards_validate_suite_vs_command!(items, cmd)
+        msg = Polyrun::Partition::Suite.command_mismatch_message(items, cmd)
+        return nil unless msg
+
+        Polyrun::Log.warn "polyrun run-shards: #{msg}"
+        2
+      end
+
       def run_shards_resolve_costs(timing_path, strategy, timing_granularity, strategy_explicit: false)
         strategy = strategy.to_s
         if timing_path

data/lib/polyrun/cli.rb

@@ -35,7 +35,7 @@ module Polyrun
     DISPATCH_SUBCOMMAND_NAMES = %w[
       plan prepare merge-coverage merge-failures merge-spec-quality report-coverage report-junit report-timing report-spec-quality report-benchmark bench
       env config merge-timing db:setup-template db:setup-shard db:clone-shards
-      run-shards parallel-rspec start build-paths init queue run-queue quick hook
+      run-shards parallel-rspec parallel-minitest parallel-quick start build-paths init queue run-queue quick hook
     ].freeze
 
     # First argv token that is a normal subcommand (not a path); if argv[0] is not here but looks like paths, run implicit parallel.
@@ -187,6 +187,10 @@ module Polyrun
         cmd_run_shards(argv, config_path)
       when "parallel-rspec"
         cmd_parallel_rspec(argv, config_path)
+      when "parallel-minitest"
+        cmd_parallel_minitest(argv, config_path)
+      when "parallel-quick"
+        cmd_parallel_quick(argv, config_path)
       when "start"
         cmd_start(argv, config_path)
       when "build-paths"

data/lib/polyrun/partition/paths.rb

@@ -23,9 +23,10 @@ module Polyrun
       end
 
       # Infer parallel suite from explicit paths (+_spec.rb+ vs +_test.rb+ vs Polyrun quick-style +.rb+).
+      # Recognizes RSpec-style +path:line+ locators (strips a trailing numeric locator before classifying).
       # Returns +:rspec+, +:minitest+, +:quick+, +:invalid+ (mixed spec and test), or +nil+ (empty).
       def infer_suite_from_paths(paths)
-        paths = paths.map { |p| File.expand_path(p) }
+        paths = Array(paths).map { |p| suite_classify_path(p) }
         return nil if paths.empty?
 
         specs = paths.count { |p| File.basename(p).end_with?("_spec.rb") }
@@ -44,8 +45,10 @@ module Polyrun
       # When +paths_file+ is set but missing, returns +{ error: "..." }+.
       # Otherwise returns +{ items:, source: }+ (human-readable source label).
       #
-      # +partition.suite+ (optional): +auto+ (default), +rspec+, +minitest+, +quick+ — used only when resolving
-      # from globs (no explicit +paths_file+ and no +spec/spec_paths.txt+).
+      # +partition.suite+ (optional): +auto+ (default), +rspec+, +minitest+, +quick+ — used when resolving
+      # from globs. Legacy +spec/spec_paths.txt+ is used only for +auto+/+rspec+ (RSpec-oriented); an
+      # explicit +minitest+/+quick+ suite skips it and globs instead. Bare +polyrun+ suite selection is
+      # {Suite.resolve_default} (explicit suite → paths_file inference → {detect_auto_suite}).
       def resolve_run_shard_items(paths_file: nil, cwd: Dir.pwd, partition: {})
         if paths_file
           abs = File.expand_path(paths_file.to_s, cwd)
@@ -53,7 +56,7 @@ module Polyrun
             return {error: "paths file not found: #{abs}"}
           end
           {items: read_lines(abs), source: paths_file.to_s}
-        elsif File.file?(File.join(cwd, "spec", "spec_paths.txt"))
+        elsif use_legacy_spec_paths?(cwd, partition)
           {items: read_lines(File.join(cwd, "spec", "spec_paths.txt")), source: "spec/spec_paths.txt"}
         else
           resolve_run_shard_items_glob(cwd: cwd, partition: partition)
@@ -104,6 +107,22 @@ module Polyrun
         require_relative "../quick/runner"
         Polyrun::Quick::Runner.parallel_default_paths(base)
       end
+
+      # Strip trailing numeric locators (+path:line+ or +path:line:column+), then expand.
+      def suite_classify_path(path)
+        raw = path.to_s.sub(/(?::\d+)+\z/, "")
+        File.expand_path(raw)
+      end
+      private_class_method :suite_classify_path
+
+      def use_legacy_spec_paths?(cwd, partition)
+        return false unless File.file?(File.join(cwd, "spec", "spec_paths.txt"))
+
+        suite = (partition["suite"] || partition[:suite] || "auto").to_s.downcase
+        suite = "auto" if suite.empty?
+        %w[auto rspec].include?(suite)
+      end
+      private_class_method :use_legacy_spec_paths?
     end
   end
 end

data/lib/polyrun/partition/suite.rb

@@ -0,0 +1,116 @@
+module Polyrun
+  module Partition
+    # Chooses the parallel runner suite for bare +polyrun+ and validates command vs path lists.
+    module Suite
+      module_function
+
+      # Resolve suite for default CLI dispatch.
+      # Order: explicit +partition.suite+ (not auto) → infer from +paths_file+ → +detect_auto_suite+.
+      # Returns +{ suite: :rspec|:minitest|:quick }+ or +{ error: "..." }+.
+      def resolve_default(cwd: Dir.pwd, partition: {})
+        configured = configured_suite(partition)
+        return {error: "unknown partition.suite: #{configured.inspect} (expected auto, rspec, minitest, quick)"} unless
+          %w[auto rspec minitest quick].include?(configured)
+
+        inferred = infer_from_paths_file(cwd, partition)
+        return inferred if inferred.is_a?(Hash) && inferred[:error]
+
+        if configured != "auto"
+          suite = configured.to_sym
+          if inferred && inferred != suite
+            return {
+              error: "partition.suite is #{suite} but paths_file infers #{inferred} " \
+                     "(fix partition.suite or the paths file)"
+            }
+          end
+          return {suite: suite}
+        end
+
+        return {suite: inferred} if inferred
+
+        auto = Paths.detect_auto_suite(cwd)
+        return {suite: auto} if auto
+
+        {
+          error: "no tests found (spec/**/*_spec.rb, test/**/*_test.rb, or Polyrun quick files). See polyrun help."
+        }
+      end
+
+      def infer_from_command(cmd)
+        tokens = Array(cmd).map(&:to_s)
+        return nil if tokens.empty?
+
+        return :rspec if tokens.any? { |t| File.basename(t) == "rspec" }
+        return :quick if tokens.include?("quick") && tokens.any? { |t| File.basename(t).include?("polyrun") }
+        return :minitest if minitest_command?(tokens)
+
+        nil
+      end
+
+      def command_mismatch_message(items, cmd)
+        path_suite = Paths.infer_suite_from_paths(Array(items))
+        cmd_suite = infer_from_command(cmd)
+
+        if path_suite == :invalid
+          return nil unless cmd_suite
+
+          return "mixing _spec.rb and _test.rb paths is not supported with a #{cmd_suite} command " \
+                 "(use a suite-agnostic custom command, or split the path list)"
+        end
+
+        return nil if path_suite.nil?
+        return nil if cmd_suite.nil?
+        return nil if path_suite == cmd_suite
+
+        "paths infer #{path_suite} but command looks like #{cmd_suite} " \
+          "(use parallel-#{path_suite}, fix partition.paths_file, or pass a matching command after --)"
+      end
+
+      def configured_suite(partition)
+        suite = (partition["suite"] || partition[:suite] || "auto").to_s.downcase
+        suite.empty? ? "auto" : suite
+      end
+      private_class_method :configured_suite
+
+      def infer_from_paths_file(cwd, partition)
+        paths_file = partition["paths_file"] || partition[:paths_file]
+        return nil unless paths_file
+
+        abs = File.expand_path(paths_file.to_s, cwd)
+        return nil unless File.file?(abs)
+
+        items = Paths.read_lines(abs)
+        inferred = Paths.infer_suite_from_paths(items)
+        return {error: "paths_file mixes _spec.rb and _test.rb (not supported in one run)"} if inferred == :invalid
+
+        inferred
+      end
+      private_class_method :infer_from_paths_file
+
+      def minitest_command?(tokens)
+        return true if tokens.any? { |t| File.basename(t) == "rails" } && tokens.include?("test")
+        return true if ruby_with_test_load_path?(tokens)
+
+        false
+      end
+      private_class_method :minitest_command?
+
+      def ruby_with_test_load_path?(tokens)
+        tokens.each_with_index do |tok, i|
+          next unless File.basename(tok) == "ruby"
+
+          rest = tokens[(i + 1)..] || []
+          rest.each_with_index do |arg, j|
+            return true if arg == "-Itest"
+            return true if arg == "-I" && rest[j + 1] == "test"
+            next unless arg.start_with?("-I") && arg.length > 2
+
+            return true if arg[2..].split(/[=:]/).include?("test")
+          end
+        end
+        false
+      end
+      private_class_method :ruby_with_test_load_path?
+    end
+  end
+end

data/lib/polyrun/rspec/example_debug_instrumentation.rb

@@ -11,9 +11,9 @@ module Polyrun
         rspec_config.around do |example|
           subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
             payload = event.payload[:sql]
-            next unless loggable_sql?(payload)
+            next unless ExampleDebug.loggable_sql?(payload)
 
-            line = sql_with_interpolated_binds(payload, event.payload[:type_casted_binds])
+            line = ExampleDebug.sql_with_interpolated_binds(payload, event.payload[:type_casted_binds])
             io.puts "+ #{line}"
           end
 

data/lib/polyrun/version.rb

@@ -1,3 +1,3 @@
 module Polyrun
-  VERSION = "2.2.3"
+  VERSION = "2.2.5"
 end

data/lib/polyrun.rb

@@ -11,6 +11,7 @@ require_relative "polyrun/coverage/reporting"
 require_relative "polyrun/coverage/rails"
 require_relative "polyrun/partition/plan"
 require_relative "polyrun/partition/paths"
+require_relative "polyrun/partition/suite"
 require_relative "polyrun/partition/paths_build"
 require_relative "polyrun/queue/file_store"
 require_relative "polyrun/data/fixtures"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polyrun
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 2.2.5
 platform: ruby
 authors:
 - Andrei Makarov
@@ -313,6 +313,7 @@ files:
 - lib/polyrun/partition/plan_sharding.rb
 - lib/polyrun/partition/reports.rb
 - lib/polyrun/partition/stable_shuffle.rb
+- lib/polyrun/partition/suite.rb
 - lib/polyrun/partition/timing_diagnostics.rb
 - lib/polyrun/partition/timing_keys.rb
 - lib/polyrun/prepare/artifacts.rb