parallel_specs 0.9.0 → 0.9.1

data/lib/parallel_specs/tasks.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "parallel_specs"
+require "rake"
+require "shellwords"
+
+module ParallelSpecs
+  module Tasks
+    class << self
+      def rails_env
+        ENV["PARALLEL_SPECS_RAILS_ENV"] || "test"
+      end
+
+      def run_in_parallel(command, options = {})
+        command = command.compact
+        num_processes = task_process_count(options[:count])
+
+        thread_count = options[:non_parallel] ? 1 : num_processes
+        results = Parallel.map(0...num_processes, in_threads: thread_count) do |process_number|
+          env = worker_env(process_number, num_processes)
+          expanded_command = expand_worker_env(command, env)
+          run_command(env, expanded_command)
+        end
+
+        abort unless results.all?
+      end
+
+      def run_command(env, command)
+        system(env, *command)
+      end
+
+      def worker_env(process_number, num_processes)
+        {
+          "TEST_ENV_NUMBER" => test_env_number(process_number),
+          "PARALLEL_SPECS_GROUPS" => num_processes.to_s,
+          "DISABLE_SPRING" => "1"
+        }
+      end
+
+      def test_env_number(process_number)
+        process_number.zero? ? "" : (process_number + 1).to_s
+      end
+
+      def suppress_output(command, ignore_regex)
+        command.compact!
+        activate_pipefail = "set -o pipefail"
+        remove_ignored_lines = %{(grep -v #{Shellwords.escape(ignore_regex)} || true)}
+
+        if system("/bin/bash", "-c", "#{activate_pipefail} 2>/dev/null")
+          shell_command = "#{activate_pipefail} && (#{Shellwords.shelljoin(command)}) | #{remove_ignored_lines}"
+          ["/bin/bash", "-c", shell_command]
+        else
+          command
+        end
+      end
+
+      def suppress_schema_load_output(command)
+        suppress_output(command, '^   ->\\|^-- ')
+      end
+
+      def check_for_pending_migrations
+        %w[db:abort_if_pending_migrations app:db:abort_if_pending_migrations].each do |task_name|
+          if Rake::Task.task_defined?(task_name)
+            Rake::Task[task_name].invoke
+            break
+          end
+        end
+      end
+
+      def purge_before_load
+        return unless defined?(ActiveRecord) && ActiveRecord.version > Gem::Version.new("4.2.0")
+
+        Rake::Task.task_defined?("db:purge") ? "db:purge" : "app:db:purge"
+      end
+
+      def schema_format_based_on_rails_version
+        if active_record_7_or_greater?
+          ActiveRecord.schema_format
+        else
+          ActiveRecord::Base.schema_format
+        end
+      end
+
+      def schema_type_based_on_rails_version
+        if active_record_61_or_greater? || schema_format_based_on_rails_version == :ruby
+          "schema"
+        else
+          "structure"
+        end
+      end
+
+      def configured_databases
+        return [] unless defined?(ActiveRecord) && active_record_61_or_greater?
+
+        @configured_databases ||= ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
+      end
+
+      def for_each_database(&block)
+        block&.call(nil)
+        return unless defined?(ActiveRecord::Tasks::DatabaseTasks)
+        return unless ActiveRecord::Tasks::DatabaseTasks.respond_to?(:for_each)
+
+        ActiveRecord::Tasks::DatabaseTasks.for_each(configured_databases) do |name|
+          block&.call(name)
+        end
+      end
+
+      def define_task_unless_defined(task_name, *args, &block)
+        return if Rake::Task.task_defined?("parallel:#{task_name}")
+
+        Rake::Task.define_task(task_name.to_sym, *args, &block)
+      end
+
+      private
+
+      def task_process_count(count)
+        num_processes = ParallelSpecs.determine_number_of_processes(count)
+        abort "Process count must be greater than 0" unless num_processes.positive?
+
+        num_processes
+      end
+
+      def expand_worker_env(command, env)
+        command.map do |part|
+          part.gsub("$TEST_ENV_NUMBER", env["TEST_ENV_NUMBER"])
+            .gsub("${TEST_ENV_NUMBER}", env["TEST_ENV_NUMBER"])
+        end
+      end
+
+      def active_record_7_or_greater?
+        ActiveRecord.version >= Gem::Version.new("7.0")
+      end
+
+      def active_record_61_or_greater?
+        ActiveRecord.version >= Gem::Version.new("6.1.0")
+      end
+    end
+  end
+end
+
+namespace :parallel do
+  desc "Setup test databases via db:setup --> parallel:setup[num_cpus]"
+  ParallelSpecs::Tasks.define_task_unless_defined(:setup, :count) do |_, args|
+    command = [$PROGRAM_NAME, "db:setup", "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}"]
+    ParallelSpecs::Tasks.run_in_parallel(ParallelSpecs::Tasks.suppress_schema_load_output(command), args)
+  end
+
+  ParallelSpecs::Tasks.for_each_database do |name|
+    task_name = "create"
+    task_name += ":#{name}" if name
+
+    desc "Create test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    ParallelSpecs::Tasks.define_task_unless_defined(task_name, :count) do |_, args|
+      ParallelSpecs::Tasks.run_in_parallel(
+        [$PROGRAM_NAME, "db:#{task_name}", "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}"],
+        args
+      )
+    end
+  end
+
+  ParallelSpecs::Tasks.for_each_database do |name|
+    task_name = "drop"
+    task_name += ":#{name}" if name
+
+    desc "Drop test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    ParallelSpecs::Tasks.define_task_unless_defined(task_name, :count) do |_, args|
+      ParallelSpecs::Tasks.run_in_parallel(
+        [
+          $PROGRAM_NAME,
+          "db:#{task_name}",
+          "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}",
+          "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+        ],
+        args
+      )
+    end
+  end
+
+  desc "Update test databases by dumping and loading --> parallel:prepare[num_cpus]"
+  ParallelSpecs::Tasks.define_task_unless_defined(:prepare, :count) do |_, args|
+    ParallelSpecs::Tasks.check_for_pending_migrations
+
+    if defined?(ActiveRecord) && [:ruby, :sql].include?(ParallelSpecs::Tasks.schema_format_based_on_rails_version)
+      type = ParallelSpecs::Tasks.schema_type_based_on_rails_version
+      Rake::Task["db:#{type}:dump"].invoke
+      ActiveRecord::Base.remove_connection if ActiveRecord::Base.configurations.any?
+      Rake::Task["parallel:load_#{type}"].invoke(args[:count])
+    else
+      task_name = Rake::Task.task_defined?("db:test:prepare") ? "db:test:prepare" : "app:db:test:prepare"
+      ParallelSpecs::Tasks.run_in_parallel([$PROGRAM_NAME, task_name], args.to_hash.merge(non_parallel: true))
+    end
+  end
+
+  ParallelSpecs::Tasks.for_each_database do |name|
+    task_name = "migrate"
+    task_name += ":#{name}" if name
+
+    desc "Update test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    ParallelSpecs::Tasks.define_task_unless_defined(task_name, :count) do |_, args|
+      ParallelSpecs::Tasks.run_in_parallel(
+        [$PROGRAM_NAME, "db:#{task_name}", "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}"],
+        args
+      )
+    end
+  end
+
+  desc "Rollback test databases via db:rollback --> parallel:rollback[num_cpus]"
+  ParallelSpecs::Tasks.define_task_unless_defined(:rollback, :count) do |_, args|
+    ParallelSpecs::Tasks.run_in_parallel(
+      [$PROGRAM_NAME, "db:rollback", "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}"],
+      args
+    )
+  end
+
+  ParallelSpecs::Tasks.for_each_database do |name|
+    rails_task = "db:schema:load"
+    rails_task += ":#{name}" if name
+
+    task_name = "load_schema"
+    task_name += ":#{name}" if name
+
+    desc "Load dumped schema for test#{" #{name}" if name} database via #{rails_task} --> parallel:#{task_name}[num_cpus]"
+    ParallelSpecs::Tasks.define_task_unless_defined(task_name, :count) do |_, args|
+      command = [
+        $PROGRAM_NAME,
+        ParallelSpecs::Tasks.purge_before_load,
+        rails_task,
+        "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}",
+        "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      ]
+      ParallelSpecs::Tasks.run_in_parallel(ParallelSpecs::Tasks.suppress_schema_load_output(command), args)
+    end
+  end
+
+  desc "Load structure for test databases via db:structure:load --> parallel:load_structure[num_cpus]"
+  ParallelSpecs::Tasks.define_task_unless_defined(:load_structure, :count) do |_, args|
+    ParallelSpecs::Tasks.run_in_parallel(
+      [
+        $PROGRAM_NAME,
+        ParallelSpecs::Tasks.purge_before_load,
+        "db:structure:load",
+        "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}",
+        "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      ],
+      args
+    )
+  end
+
+  desc "Load the seed data from db/seeds.rb via db:seed --> parallel:seed[num_cpus]"
+  ParallelSpecs::Tasks.define_task_unless_defined(:seed, :count) do |_, args|
+    ParallelSpecs::Tasks.run_in_parallel(
+      [$PROGRAM_NAME, "db:seed", "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}"],
+      args
+    )
+  end
+
+  desc "Launch given rake command in parallel"
+  ParallelSpecs::Tasks.define_task_unless_defined(:rake, :command, :count) do |_, args|
+    ParallelSpecs::Tasks.run_in_parallel(
+      [$PROGRAM_NAME, args.command, "RAILS_ENV=#{ParallelSpecs::Tasks.rails_env}"],
+      args
+    )
+  end
+end

data/lib/parallel_specs/test/runner.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-require 'parallel_specs'
-require 'shellwords'
+require "parallel_specs"
+require "shellwords"
 
 module ParallelSpecs
   module Test
     class Runner
       RuntimeLogTooSmallError = Class.new(StandardError)
       RuntimeLogParseError = Class.new(StandardError)
+      MissingTestFileError = Class.new(ArgumentError)
+      OUTPUT_MUTEX = Mutex.new
 
       class << self
         def tests_in_groups(tests, num_groups, options = {})
@@ -37,13 +39,13 @@ module ParallelSpecs
             rescue RuntimeLogParseError => e
               warn "parallel_specs: unable to use runtime log #{runtime_log_path(options)}: #{e.message}; falling back to filesize grouping"
               known_runtimes = {}
-            rescue StandardError => e
+            rescue => e
               warn "parallel_specs: unable to load runtime log #{runtime_log_path(options)}: #{e.class}: #{e.message}"
               raise
             end
 
             if known_runtimes.size * 1.5 > tests.size
-              puts 'Using recorded test runtime'
+              puts "Using recorded test runtime"
               sort_by_runtime(tests, known_runtimes)
             else
               sort_by_filesize(tests)
@@ -57,13 +59,13 @@ module ParallelSpecs
 
         def execute_command(cmd, process_number, num_processes, options)
           env = {
-            'TEST_ENV_NUMBER' => test_env_number(process_number),
-            'PARALLEL_SPECS_GROUPS' => num_processes.to_s,
-            'PARALLEL_SPECS_PID_FILE' => ParallelSpecs.pid_file_path
+            "TEST_ENV_NUMBER" => test_env_number(process_number),
+            "PARALLEL_SPECS_GROUPS" => num_processes.to_s,
+            "PARALLEL_SPECS_PID_FILE" => ParallelSpecs.pid_file_path
           }
 
           if (dashboard_event_files = options[:dashboard_event_files])
-            env['PARALLEL_SPECS_DASHBOARD_EVENT_LOG'] = dashboard_event_files.fetch(process_number)
+            env["PARALLEL_SPECS_DASHBOARD_EVENT_LOG"] = dashboard_event_files.fetch(process_number)
           end
 
           execute_command_and_capture_output(env, cmd, options)
@@ -88,13 +90,13 @@ module ParallelSpecs
             1
           end
 
-          { env: env, stdout: output, exit_status: exit_status, command: cmd, seed: seed_from(output) }
+          {env: env, stdout: output, exit_status: exit_status, command: cmd, seed: seed_from(output)}
         end
 
         def print_command(command, env = {})
-          env_string = rerun_env(env).map { |key, value| "#{key}=#{Shellwords.escape(value)}" }.join(' ')
+          env_string = rerun_env(env).map { |key, value| "#{key}=#{Shellwords.escape(value)}" }.join(" ")
           command_string = Shellwords.shelljoin(command)
-          puts [env_string, command_string].reject(&:empty?).join(' ')
+          puts [env_string, command_string].reject(&:empty?).join(" ")
         end
 
         def rerun_command(command, seed: nil)
@@ -102,37 +104,39 @@ module ParallelSpecs
         end
 
         def command_with_seed(command, seed)
-          [*remove_command_arguments(command, '--seed'), '--seed', seed]
+          [*remove_command_arguments(command, "--seed"), "--seed", seed]
         end
 
         def find_results(test_output)
           test_output.lines.filter_map do |line|
-            line = line.chomp.gsub(/\e\[\d+m/, '')
+            line = line.chomp.gsub(/\e\[\d+m/, "")
             line if line_is_result?(line)
           end
         end
 
         def summarize_results(results)
-          sum_up_results(results).sort.map { |word, count| "#{count} #{word}#{'s' if count != 1}" }.join(', ')
+          sum_up_results(results).sort.map { |word, count| "#{count} #{word}#{"s" if count != 1}" }.join(", ")
         end
 
         protected
 
         def capture_output(out, dashboard)
-          result = +''
+          result = +""
           begin
             loop do
               chunk = out.readpartial(1_000_000)
               chunk = chunk.force_encoding(Encoding.default_internal) if Encoding.default_internal
               result << chunk
-              next if dashboard
-
-              $stdout.print(chunk)
-              $stdout.flush
             end
           rescue EOFError
             nil
           end
+          unless dashboard
+            OUTPUT_MUTEX.synchronize do
+              $stdout.print(result)
+              $stdout.flush
+            end
+          end
           result
         end
 
@@ -161,7 +165,7 @@ module ParallelSpecs
           File.read(path).split("\n").each_with_index.each_with_object({}) do |(line, index), times|
             next if line.empty?
 
-            test, separator, time = line.rpartition(':')
+            test, separator, time = line.rpartition(":")
             raise RuntimeLogParseError, "Invalid runtime log line #{index + 1} in #{path}: #{line.inspect}" if separator.empty? || test.empty? || time.empty?
 
             times[test] = Float(time) if tests.include?(test)
@@ -182,9 +186,11 @@ module ParallelSpecs
         def find_tests(tests, options = {})
           tests.flat_map do |file_or_folder|
             if File.directory?(file_or_folder)
-              filter_files(Dir[File.join(file_or_folder, '**/*_spec.rb')].uniq.sort, options)
-            else
+              filter_files(Dir[File.join(file_or_folder, "**/*_spec.rb")].uniq.sort, options)
+            elsif File.exist?(file_or_folder)
               filter_files([file_or_folder], options)
+            else
+              raise MissingTestFileError, "No such spec file or directory: #{file_or_folder}"
             end
           end.uniq
         end
@@ -213,15 +219,15 @@ module ParallelSpecs
         end
 
         def rerun_env(env)
-          env.slice('TEST_ENV_NUMBER', 'PARALLEL_SPECS_GROUPS').reject { |_key, value| value.to_s.empty? }
+          env.slice("TEST_ENV_NUMBER", "PARALLEL_SPECS_GROUPS").reject { |_key, value| value.to_s.empty? }
         end
 
         def test_env_number(process_number)
-          process_number.zero? ? '' : (process_number + 1).to_s
+          process_number.zero? ? "" : (process_number + 1).to_s
         end
 
         def sum_up_results(results)
-          results.join(' ').gsub(/s\b/, '').scan(/(\d+) (\w+)/).each_with_object(Hash.new(0)) do |(number, word), sum|
+          results.join(" ").gsub(/s\b/, "").scan(/(\d+) (\w+)/).each_with_object(Hash.new(0)) do |(number, word), sum|
             sum[word] += number.to_i
           end
         end

data/lib/parallel_specs/version.rb

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

data/lib/parallel_specs.rb

@@ -1,35 +1,40 @@
 # frozen_string_literal: true
 
-require 'parallel'
-require 'rbconfig'
-require 'tempfile'
+require "parallel"
+require "rbconfig"
+require "tempfile"
 
 module ParallelSpecs
-  WINDOWS = (RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
-  RUBY_BINARY = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  ConfigurationError = Class.new(ArgumentError)
+  WINDOWS = (RbConfig::CONFIG["host_os"] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
+  RUBY_BINARY = File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
 
-  autoload :CLI, 'parallel_specs/cli'
-  autoload :VERSION, 'parallel_specs/version'
-  autoload :Grouper, 'parallel_specs/grouper'
-  autoload :Pids, 'parallel_specs/pids'
+  autoload :CLI, "parallel_specs/cli"
+  autoload :VERSION, "parallel_specs/version"
+  autoload :Grouper, "parallel_specs/grouper"
+  autoload :Pids, "parallel_specs/pids"
 
   class << self
     def determine_number_of_processes(count)
-      Integer([
-        count,
-        ENV['PARALLEL_SPECS_PROCESSORS'],
-        Parallel.processor_count
-      ].detect { |value| !value.to_s.strip.empty? })
+      source, value = [
+        ["process count", count],
+        ["PARALLEL_SPECS_PROCESSORS", ENV["PARALLEL_SPECS_PROCESSORS"]],
+        ["processor count", Parallel.processor_count]
+      ].detect { |_source, raw_value| !raw_value.to_s.strip.empty? }
+
+      Integer(value)
+    rescue ArgumentError
+      raise ConfigurationError, "#{source} must be an integer"
     end
 
     def with_pid_file
-      previous_pid_file = ENV['PARALLEL_SPECS_PID_FILE']
-      Tempfile.open('parallel_specs-pidfile') do |file|
-        ENV['PARALLEL_SPECS_PID_FILE'] = file.path
+      previous_pid_file = ENV["PARALLEL_SPECS_PID_FILE"]
+      Tempfile.open("parallel_specs-pidfile") do |file|
+        ENV["PARALLEL_SPECS_PID_FILE"] = file.path
         @pids = pids
         yield
       ensure
-        ENV['PARALLEL_SPECS_PID_FILE'] = previous_pid_file
+        ENV["PARALLEL_SPECS_PID_FILE"] = previous_pid_file
         @pids = nil
       end
     end
@@ -39,11 +44,11 @@ module ParallelSpecs
     end
 
     def pid_file_available?
-      !ENV['PARALLEL_SPECS_PID_FILE'].to_s.empty?
+      !ENV["PARALLEL_SPECS_PID_FILE"].to_s.empty?
     end
 
     def pid_file_path
-      ENV.fetch('PARALLEL_SPECS_PID_FILE')
+      ENV.fetch("PARALLEL_SPECS_PID_FILE")
     end
 
     def stop_all_processes
@@ -68,17 +73,17 @@ module ParallelSpecs
       previous = nil
       current = File.expand_path(Dir.pwd)
       until !File.directory?(current) || current == previous
-        return true if File.exist?(File.join(current, 'Gemfile'))
+        return true if File.exist?(File.join(current, "Gemfile"))
 
         previous = current
-        current = File.expand_path('..', current)
+        current = File.expand_path("..", current)
       end
 
       false
     end
 
     def with_ruby_binary(command)
-      WINDOWS ? [RUBY_BINARY, '--', command] : [command]
+      WINDOWS ? [RUBY_BINARY, "--", command] : [command]
     end
 
     def now
@@ -92,3 +97,5 @@ module ParallelSpecs
     end
   end
 end
+
+require "parallel_specs/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_specs
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Scott Watermasysk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-07 00:00:00.000000000 Z
+date: 2026-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -65,10 +65,12 @@ files:
 - lib/parallel_specs/cli/dashboard.rb
 - lib/parallel_specs/grouper.rb
 - lib/parallel_specs/pids.rb
+- lib/parallel_specs/railtie.rb
 - lib/parallel_specs/rspec/dashboard_logger.rb
 - lib/parallel_specs/rspec/logger_base.rb
 - lib/parallel_specs/rspec/runner.rb
 - lib/parallel_specs/rspec/runtime_logger.rb
+- lib/parallel_specs/tasks.rb
 - lib/parallel_specs/test/runner.rb
 - lib/parallel_specs/version.rb
 homepage: https://github.com/scottwater/parallel_specs