polyrun 2.2.4 → 2.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de79eaae07044fa991b839a44011f7648df5ba16d0586a1ea2708c1d7160cf5e
-  data.tar.gz: f3cbab3bf642164ffa507aa75be1acaaf7a232057b1b1c5f3fcdb0f804c2a0a7
+  metadata.gz: 6364a918386209ff30b2c12280f3a37a0cb70de54a83f1f07606c2c526ac773c
+  data.tar.gz: 8d75d162af33d721f864cf8a4002d98f57e53d24db55dc607dad82e94f5416f7
 SHA512:
-  metadata.gz: f62f0cbc1760e3fc42a4711b7e55eace3b8b5bb038836abcae91eba876cfabf9b72832e2f04a284744fdf09247288bff6b60c7a3b1a38d00ee140d37634702df
-  data.tar.gz: 4f9b6d94992745419d35a5bbb40041094569f725470904f546566bfdba7a3e7eeca899f5b80844d9908ca36e744870fef3f8ecef6e20d589fa090d0363859147
+  metadata.gz: e92439850018abacae0f1041315b213f4624abc78e49b3d4ca53d53129428790961b1d77b8a923d882e0fe0c9157c14c125ab13bbdf34db52c86c82082917104
+  data.tar.gz: 6d64c292b054ffd8cf95a47bda1fa3253284af76e98d8d9fc32631b389e51e9acbf2b3ad6c0e64e19f471847fba17b00b706ef1d4d8c549414abea9be4a9806a

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 # CHANGELOG
 
-## Unreleased
+## 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)
 

data/README.md

@@ -10,7 +10,7 @@ Running tests in parallel across processes still requires a single merged covera
 
 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_*`.
@@ -92,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/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/version.rb

@@ -1,3 +1,3 @@
 module Polyrun
-  VERSION = "2.2.4"
+  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.4
+  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