parallel_specs 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7220b40d98f5c203c37cc69d12e9145e909dd4877d35e77fb0ae011f23ab3d3e
-  data.tar.gz: 40eadee9e0eb4748c3c17ad8c4b0bf016328c4564d655e014c8a0e22fbc5ae81
+  metadata.gz: 3cd867c0ba3d8a33ab05fb0a4f6690750fbeeecf4b2fd2e149cd649545aa27b2
+  data.tar.gz: bc1de229e2308c537a09bca00ac8dd70f7b085e91a6327b9e01cca89336e4812
 SHA512:
-  metadata.gz: 83ae2b21bd87c2445be0a1af045df3a2e0563a84eded7c62d08cb47792f7bc73d55f6416dea0aaa37b3ae49ebac3876804eb391c5219ff4c521e88074188aed5
-  data.tar.gz: 12bef5dbb566c689b5721f5a88339a69c3936eae64f1251977b4e1c847de2ab41c5e518d911ea31a4405321bbf9a2fabc6dd35d5942cc44ce35c7ec0e0015d76
+  metadata.gz: 62156a6183d0e584b235a22ea195bacfde07b7a3ef5b1a5744c4a9a4d0cd445b10ca99311fd22357fcea58104763fa76c642e268add3fcfae45339e7ab5b9d4b
+  data.tar.gz: 18d8f259aaf40b753c8b2f7cf2472b0a36d0a2b4a24095446da00cad529f62d66209fb5195036fccb2a9efc796075eb46d5e92623ad750c5fa7bd7c1a6ad5a32

data/README.md

@@ -71,6 +71,22 @@ bundle exec parallel_specs --record-runtime --runtime-log tmp/my_runtime.log
 
 `--runtime-log PATH` is used as the input path for balancing and, with `--record-runtime`, as the output destination for the completed run.
 
+## Keeping specs on dedicated workers
+
+Use `--single` with `--isolate` to keep matching specs together on a dedicated worker. For example, on a 16-worker run:
+
+```bash
+bundle exec parallel_specs -n 16 --single spec/features --isolate
+```
+
+All files matching `spec/features` run sequentially on worker 1, while workers 2–16 handle the remaining specs. If `--isolate` is omitted, runtime balancing can add ordinary specs to the worker running the singled specs.
+
+`--single` is repeatable when more than one pattern should use the singled worker. To spread singled specs across two dedicated workers instead, use `--isolate-n 2`:
+
+```bash
+bundle exec parallel_specs -n 16 --single spec/features --isolate-n 2
+```
+
 ## Rails database tasks
 
 Rails apps that use `TEST_ENV_NUMBER` in `config/database.yml` can prepare per-worker test databases without depending on `parallel_tests`.

data/lib/parallel_specs/cli.rb

@@ -344,6 +344,13 @@ module ParallelSpecs
           runtime - info from runtime log
           default - runtime when runtime log is filled otherwise filesize
         TEXT
+        opts.on("-s PATTERN", "--single PATTERN", "Run all matching spec files in the same process") do |pattern|
+          (options[:single_process] ||= []) << Regexp.new(pattern)
+        end
+        opts.on("-i", "--isolate", "Do not run other specs in workers reserved by --single") { options[:isolate] = true }
+        opts.on("--isolate-n PROCESSES", Integer, "Spread --single specs across this many isolated workers") do |count|
+          options[:isolate_count] = count
+        end
         opts.on("--dashboard-mode MODE", %w[interactive plain], "Dashboard mode: interactive or plain") { |mode| options[:dashboard_mode] = mode.to_sym }
         opts.on("--plain-dashboard", "Use the plain text dashboard output") { options[:dashboard_mode] = :plain }
         opts.on("--plain", "Use the plain text dashboard output") { options[:dashboard_mode] = :plain }
@@ -364,8 +371,6 @@ module ParallelSpecs
         }
       end.parse!(cli_argv)
 
-      options[:dashboard] = !options[:record_runtime]
-
       files, remaining = extract_file_paths(cli_argv, rspec_argv)
       files = [@runner.default_test_folder] if files.empty?
       options[:files] = files.map { |file_path| Pathname.new(file_path).cleanpath.to_s }

data/lib/parallel_specs/grouper.rb

@@ -3,13 +3,27 @@
 module ParallelSpecs
   class Grouper
     class << self
-      def in_even_groups_by_size(items, num_groups, _options = {})
+      def in_even_groups_by_size(items, num_groups, options = {})
         groups = Array.new(num_groups) { {items: [], size: 0} }
+        single_process_patterns = options[:single_process] || []
+        single_items, items = items.partition do |item, _size|
+          single_process_patterns.any? { |pattern| item.match?(pattern) }
+        end
+        isolate_count = isolated_process_count(options)
 
-        items_to_group(items).each do |item, size|
-          group = groups.min_by { |entry| entry[:size] }
-          group[:items] << item
-          group[:size] += size || 1
+        if options.key?(:isolate_count) && !isolate_count.positive?
+          raise ParallelSpecs::ConfigurationError, "Isolated process count must be greater than 0"
+        end
+        if isolate_count >= num_groups
+          raise ParallelSpecs::ConfigurationError, "Isolated process count must be less than total process count"
+        end
+
+        if isolate_count.positive?
+          group_by_size(single_items, groups.first(isolate_count))
+          group_by_size(items, groups.drop(isolate_count))
+        else
+          single_items.each { |item, size| add_to_group(groups.first, item, size) }
+          group_by_size(items, groups)
         end
 
         groups.map { |group| group[:items].sort }
@@ -17,6 +31,21 @@ module ParallelSpecs
 
       private
 
+      def isolated_process_count(options)
+        options[:isolate_count] || (options[:isolate] ? 1 : 0)
+      end
+
+      def group_by_size(items, groups)
+        items_to_group(items).each do |item, size|
+          add_to_group(groups.min_by { |group| group[:size] }, item, size)
+        end
+      end
+
+      def add_to_group(group, item, size)
+        group[:items] << item
+        group[:size] += size || 1
+      end
+
       def items_to_group(items)
         return items unless items.first&.size == 2
 

data/lib/parallel_specs/rspec/runner.rb

@@ -114,7 +114,7 @@ module ParallelSpecs
             options[:runtime_log] || runtime_log
           end
 
-          ["--format", "progress", "--format", "ParallelSpecs::RSpec::RuntimeLogger", "--out", runtime_log_path]
+          ["--format", "ParallelSpecs::RSpec::RuntimeLogger", "--out", runtime_log_path]
         end
       end
     end

data/lib/parallel_specs/test/runner.rb

@@ -13,7 +13,7 @@ module ParallelSpecs
 
       class << self
         def tests_in_groups(tests, num_groups, options = {})
-          ParallelSpecs::Grouper.in_even_groups_by_size(tests_with_size(tests, options), num_groups)
+          ParallelSpecs::Grouper.in_even_groups_by_size(tests_with_size(tests, options), num_groups, options)
         end
 
         def tests_with_size(tests, options)

data/lib/parallel_specs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ParallelSpecs
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_specs
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Scott Watermasysk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-15 00:00:00.000000000 Z
+date: 2026-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel