polyrun 1.1.0 → 1.3.0

data/lib/polyrun/coverage/collector.rb

@@ -8,6 +8,7 @@ require_relative "formatter"
 require_relative "merge"
 require_relative "result"
 require_relative "track_files"
+require_relative "collector_fragment_meta"
 require_relative "../debug"
 
 module Polyrun
@@ -24,7 +25,7 @@ module Polyrun
 
       # @param root [String] project root (absolute or relative)
       # @param reject_patterns [Array<String>] path substrings to drop (like SimpleCov add_filter)
-      # @param output_path [String, nil] default coverage/polyrun-fragment-<shard>.json
+      # @param output_path [String, nil] default see {.fragment_default_basename_from_env}
       # @param minimum_line_percent [Float, nil] exit 1 if below (when strict)
       # @param strict [Boolean] whether to exit non-zero on threshold failure (default true when minimum set)
       # @param track_under [Array<String>] when +track_files+ is nil, only keep coverage keys under these dirs relative to +root+. Default +["lib"]+.
@@ -34,18 +35,25 @@ module Polyrun
       # @param formatter [Object, nil] Object responding to +format(result, output_dir:, basename:)+ like SimpleCov formatters (e.g. {Formatter.multi} or {Formatter::MultiFormatter})
       # @param report_output_dir [String, nil] directory for +formatter+ outputs (default +coverage/+ under +root+)
       # @param report_basename [String] file prefix for formatter outputs (default +polyrun-coverage+)
+      # See {CollectorFragmentMeta.fragment_default_basename_from_env}.
+      def self.fragment_default_basename_from_env(env = ENV)
+        CollectorFragmentMeta.fragment_default_basename_from_env(env)
+      end
+
       def start!(root:, reject_patterns: [], track_under: ["lib"], track_files: nil, groups: nil, output_path: nil, minimum_line_percent: nil, strict: nil, meta: {}, formatter: nil, report_output_dir: nil, report_basename: "polyrun-coverage")
         return if disabled?
 
         root = File.expand_path(root)
-        shard = ENV.fetch("POLYRUN_SHARD_INDEX", "0")
-        output_path ||= File.join(root, "coverage", "polyrun-fragment-#{shard}.json")
+        basename = fragment_default_basename_from_env
+        output_path ||= File.join(root, "coverage", "polyrun-fragment-#{basename}.json")
         strict = if minimum_line_percent.nil?
           false
         else
           strict.nil? || strict
         end
 
+        fragment_meta = CollectorFragmentMeta.fragment_meta_from_env(basename)
+
         @config = {
           root: root,
           track_under: Array(track_under).map(&:to_s),
@@ -59,7 +67,8 @@ module Polyrun
           formatter: formatter,
           report_output_dir: report_output_dir,
           report_basename: report_basename,
-          shard_total_at_start: ENV["POLYRUN_SHARD_TOTAL"].to_i
+          shard_total_at_start: ENV["POLYRUN_SHARD_TOTAL"].to_i,
+          fragment_meta: fragment_meta
         }
 
         unless ::Coverage.running?
@@ -110,11 +119,7 @@ module Polyrun
       end
 
       def self.finish_debug_time_label
-        if ENV["POLYRUN_SHARD_TOTAL"].to_i > 1
-          "worker pid=#{$$} shard=#{ENV.fetch("POLYRUN_SHARD_INDEX", "?")} Coverage::Collector.finish (write fragment)"
-        else
-          "Coverage::Collector.finish (write fragment)"
-        end
+        CollectorFragmentMeta.finish_debug_time_label
       end
 
       def build_meta(cfg)
@@ -123,6 +128,7 @@ module Polyrun
         m["timestamp"] ||= Time.now.to_i
         m["command_name"] ||= "rspec"
         m["polyrun_coverage_root"] = cfg[:root].to_s
+        CollectorFragmentMeta.merge_fragment_meta!(m, cfg[:fragment_meta])
         if cfg[:groups]
           m["polyrun_coverage_groups"] = cfg[:groups].transform_keys(&:to_s).transform_values(&:to_s)
         end

data/lib/polyrun/coverage/collector_finish.rb

@@ -12,6 +12,8 @@ module Polyrun
           collector_finish: "start",
           polyrun_shard_index: ENV["POLYRUN_SHARD_INDEX"],
           polyrun_shard_total: ENV["POLYRUN_SHARD_TOTAL"],
+          polyrun_shard_matrix_index: ENV["POLYRUN_SHARD_MATRIX_INDEX"],
+          polyrun_shard_matrix_total: ENV["POLYRUN_SHARD_MATRIX_TOTAL"],
           output_path: cfg[:output_path]
         )
         Polyrun::Debug.time(Collector.finish_debug_time_label) do

data/lib/polyrun/coverage/collector_fragment_meta.rb

@@ -0,0 +1,57 @@
+module Polyrun
+  module Coverage
+    # Shard / worker naming for coverage JSON fragments (N×M CI vs run-shards).
+    module CollectorFragmentMeta
+      module_function
+
+      # Default fragment basename (no extension) for +coverage/polyrun-fragment-<basename>.json+.
+      def fragment_default_basename_from_env(env = ENV)
+        local = env.fetch("POLYRUN_SHARD_INDEX", "0")
+        mt = env["POLYRUN_SHARD_MATRIX_TOTAL"].to_i
+        if mt > 1
+          mi = env.fetch("POLYRUN_SHARD_MATRIX_INDEX", "0")
+          "shard#{mi}-worker#{local}"
+        elsif env["POLYRUN_SHARD_TOTAL"].to_i > 1
+          "worker#{local}"
+        else
+          local
+        end
+      end
+
+      def finish_debug_time_label
+        mt = ENV["POLYRUN_SHARD_MATRIX_TOTAL"].to_i
+        if mt > 1
+          "worker pid=#{$$} shard(matrix)=#{ENV.fetch("POLYRUN_SHARD_MATRIX_INDEX", "?")} worker(local)=#{ENV.fetch("POLYRUN_SHARD_INDEX", "?")} Coverage::Collector.finish (write fragment)"
+        elsif ENV["POLYRUN_SHARD_TOTAL"].to_i > 1
+          "worker pid=#{$$} worker=#{ENV.fetch("POLYRUN_SHARD_INDEX", "?")} Coverage::Collector.finish (write fragment)"
+        else
+          "Coverage::Collector.finish (write fragment)"
+        end
+      end
+
+      def fragment_meta_from_env(basename)
+        mt = ENV["POLYRUN_SHARD_MATRIX_TOTAL"].to_i
+        {
+          basename: basename,
+          worker_index: ENV.fetch("POLYRUN_SHARD_INDEX", "0"),
+          shard_matrix_index: shard_matrix_index_value(mt)
+        }
+      end
+
+      def shard_matrix_index_value(matrix_total)
+        return nil if matrix_total <= 1
+
+        ENV.fetch("POLYRUN_SHARD_MATRIX_INDEX", "0")
+      end
+
+      def merge_fragment_meta!(m, fm)
+        return m if fm.nil?
+
+        m["polyrun_fragment_basename"] = fm[:basename].to_s if fm[:basename]
+        m["polyrun_worker_index"] = fm[:worker_index].to_s if fm[:worker_index]
+        m["polyrun_shard_matrix_index"] = fm[:shard_matrix_index].to_s if fm[:shard_matrix_index]
+        m
+      end
+    end
+  end
+end

data/lib/polyrun/partition/paths.rb

@@ -8,9 +8,45 @@ module Polyrun
         File.read(File.expand_path(path.to_s, Dir.pwd)).split("\n").map(&:strip).reject(&:empty?)
       end
 
+      # Prefer +spec/+ RSpec files, then +test/+ Minitest, then Polyrun Quick files (same globs as +polyrun quick+).
+      # Order avoids running the broader Quick glob when RSpec or Minitest files already exist.
+      def detect_auto_suite(cwd = Dir.pwd)
+        base = File.expand_path(cwd)
+        return :rspec if Dir.glob(File.join(base, "spec/**/*_spec.rb")).any?
+
+        return :minitest if Dir.glob(File.join(base, "test/**/*_test.rb")).any?
+
+        quick = quick_parallel_default_paths(base)
+        return :quick if quick.any?
+
+        nil
+      end
+
+      # Infer parallel suite from explicit paths (+_spec.rb+ vs +_test.rb+ vs Polyrun quick-style +.rb+).
+      # 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) }
+        return nil if paths.empty?
+
+        specs = paths.count { |p| File.basename(p).end_with?("_spec.rb") }
+        tests = paths.count { |p| File.basename(p).end_with?("_test.rb") }
+        return :invalid if specs.positive? && tests.positive?
+
+        return :rspec if specs.positive?
+        return :minitest if tests.positive?
+
+        others = paths.size - specs - tests
+        return :quick if others.positive?
+
+        nil
+      end
+
       # When +paths_file+ is set but missing, returns +{ error: "..." }+.
       # Otherwise returns +{ items:, source: }+ (human-readable source label).
-      def resolve_run_shard_items(paths_file: nil, cwd: Dir.pwd)
+      #
+      # +partition.suite+ (optional): +auto+ (default), +rspec+, +minitest+, +quick+ — used only when resolving
+      # from globs (no explicit +paths_file+ and no +spec/spec_paths.txt+).
+      def resolve_run_shard_items(paths_file: nil, cwd: Dir.pwd, partition: {})
         if paths_file
           abs = File.expand_path(paths_file.to_s, cwd)
           unless File.file?(abs)
@@ -20,9 +56,54 @@ module Polyrun
         elsif File.file?(File.join(cwd, "spec", "spec_paths.txt"))
           {items: read_lines(File.join(cwd, "spec", "spec_paths.txt")), source: "spec/spec_paths.txt"}
         else
-          {items: Dir.glob(File.join(cwd, "spec/**/*_spec.rb")).sort, source: "spec/**/*_spec.rb glob"}
+          resolve_run_shard_items_glob(cwd: cwd, partition: partition)
         end
       end
+
+      def resolve_run_shard_items_glob(cwd:, partition: {})
+        suite = (partition["suite"] || partition[:suite] || "auto").to_s.downcase
+        suite = "auto" if suite.empty?
+
+        base = File.expand_path(cwd)
+        spec = Dir.glob(File.join(base, "spec/**/*_spec.rb")).sort
+        test = Dir.glob(File.join(base, "test/**/*_test.rb")).sort
+        quick = quick_parallel_default_paths(base)
+
+        case suite
+        when "rspec"
+          return {error: "partition.suite is rspec but no spec/**/*_spec.rb files"} if spec.empty?
+
+          {items: spec, source: "spec/**/*_spec.rb glob"}
+        when "minitest"
+          return {error: "partition.suite is minitest but no test/**/*_test.rb files"} if test.empty?
+
+          {items: test, source: "test/**/*_test.rb glob"}
+        when "quick"
+          return {error: "partition.suite is quick but no Polyrun quick files under spec/ or test/"} if quick.empty?
+
+          {items: quick, source: "Polyrun quick glob"}
+        when "auto"
+          if spec.any?
+            {items: spec, source: "spec/**/*_spec.rb glob"}
+          elsif test.any?
+            {items: test, source: "test/**/*_test.rb glob"}
+          elsif quick.any?
+            {items: quick, source: "Polyrun quick glob"}
+          else
+            {
+              error: "no spec paths (spec/spec_paths.txt, partition.paths_file, or spec/**/*_spec.rb); " \
+                     "no test/**/*_test.rb; no Polyrun quick files"
+            }
+          end
+        else
+          {error: "unknown partition.suite: #{suite.inspect} (expected auto, rspec, minitest, quick)"}
+        end
+      end
+
+      def quick_parallel_default_paths(base)
+        require_relative "../quick/runner"
+        Polyrun::Quick::Runner.parallel_default_paths(base)
+      end
     end
   end
 end

data/lib/polyrun/quick/runner.rb

@@ -62,6 +62,30 @@ module Polyrun
         new(out: out, err: err, verbose: verbose).run(paths)
       end
 
+      # Files Polyrun::Quick would run with no explicit paths (excludes normal RSpec/Minitest files).
+      def self.parallel_default_paths(cwd = Dir.pwd)
+        base = File.expand_path(cwd)
+        globs = [
+          File.join(base, "spec", "polyrun_quick", "**", "*.rb"),
+          File.join(base, "test", "polyrun_quick", "**", "*.rb"),
+          File.join(base, "spec", "**", "*.rb"),
+          File.join(base, "test", "**", "*.rb")
+        ]
+        globs.flat_map { |g| Dir.glob(g) }.uniq.reject { |p| quick_path_excluded?(p, base) }.sort
+      end
+
+      def self.quick_path_excluded?(path, base)
+        rel = Pathname.new(path).relative_path_from(Pathname.new(base)).to_s
+        parts = rel.split(File::SEPARATOR)
+        bn = File.basename(path)
+        return true if bn.end_with?("_spec.rb", "_test.rb")
+        return true if %w[spec_helper.rb rails_helper.rb test_helper.rb].include?(bn)
+        return true if parts[0] == "spec" && %w[support fixtures factories].include?(parts[1])
+        return true if parts[0] == "test" && %w[support fixtures].include?(parts[1])
+
+        false
+      end
+
       def initialize(out: $stdout, err: $stderr, verbose: false)
         @out = out
         @err = err
@@ -153,27 +177,12 @@ module Polyrun
       end
 
       def default_globs
-        base = File.expand_path(Dir.pwd)
-        globs = [
-          File.join(base, "spec", "polyrun_quick", "**", "*.rb"),
-          File.join(base, "test", "polyrun_quick", "**", "*.rb"),
-          File.join(base, "spec", "**", "*.rb"),
-          File.join(base, "test", "**", "*.rb")
-        ]
-        globs.flat_map { |g| Dir.glob(g) }.uniq.reject { |p| default_quick_exclude?(p, base) }.sort
+        Runner.parallel_default_paths(Dir.pwd)
       end
 
       # Omit RSpec/Minitest files and common helpers so +polyrun quick+ with no args does not load normal suites.
       def default_quick_exclude?(path, base)
-        rel = Pathname.new(path).relative_path_from(Pathname.new(base)).to_s
-        parts = rel.split(File::SEPARATOR)
-        bn = File.basename(path)
-        return true if bn.end_with?("_spec.rb", "_test.rb")
-        return true if %w[spec_helper.rb rails_helper.rb test_helper.rb].include?(bn)
-        return true if parts[0] == "spec" && %w[support fixtures factories].include?(parts[1])
-        return true if parts[0] == "test" && %w[support fixtures].include?(parts[1])
-
-        false
+        Runner.quick_path_excluded?(path, base)
       end
     end
   end

data/lib/polyrun/templates/ci_matrix.polyrun.yml

@@ -3,8 +3,9 @@
 #   bundle exec polyrun -c polyrun.yml ci-shard-run -- bundle exec rspec
 # (or ci-shard-rspec; or e.g. ci-shard-run -- bundle exec polyrun quick).
 # Equivalent to build-paths, plan --shard/--total, then run that command with this slice's paths.
-# A separate CI job downloads coverage/polyrun-fragment-*.json and runs merge-coverage.
-# Do not use parallel-rspec with multiple workers inside the same matrix row unless you intend nested parallelism.
+# A separate CI job downloads coverage/polyrun-fragment-*.json (e.g. shard<S>-worker<W>.json per N×M process) and runs merge-coverage.
+# For N×M (N matrix jobs × M processes per job): set shard_processes: M or POLYRUN_SHARD_PROCESSES,
+# or pass --shard-processes M to ci-shard-run / ci-shard-rspec (local split is round-robin).
 # See: docs/SETUP_PROFILE.md
 
 partition:

data/lib/polyrun/version.rb

@@ -1,3 +1,3 @@
 module Polyrun
-  VERSION = "1.1.0"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polyrun
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -167,10 +167,14 @@ files:
 - lib/polyrun.rb
 - lib/polyrun/cli.rb
 - lib/polyrun/cli/ci_shard_run_command.rb
+- lib/polyrun/cli/ci_shard_run_parse.rb
+- lib/polyrun/cli/config_command.rb
 - lib/polyrun/cli/coverage_commands.rb
 - lib/polyrun/cli/coverage_merge_io.rb
 - lib/polyrun/cli/database_commands.rb
+- lib/polyrun/cli/default_run.rb
 - lib/polyrun/cli/env_commands.rb
+- lib/polyrun/cli/help.rb
 - lib/polyrun/cli/helpers.rb
 - lib/polyrun/cli/init_command.rb
 - lib/polyrun/cli/plan_command.rb
@@ -187,9 +191,13 @@ files:
 - lib/polyrun/cli/start_bootstrap.rb
 - lib/polyrun/cli/timing_command.rb
 - lib/polyrun/config.rb
+- lib/polyrun/config/dotted_path.rb
+- lib/polyrun/config/effective.rb
+- lib/polyrun/config/resolver.rb
 - lib/polyrun/coverage/cobertura_zero_lines.rb
 - lib/polyrun/coverage/collector.rb
 - lib/polyrun/coverage/collector_finish.rb
+- lib/polyrun/coverage/collector_fragment_meta.rb
 - lib/polyrun/coverage/filter.rb
 - lib/polyrun/coverage/formatter.rb
 - lib/polyrun/coverage/merge.rb