parallel_specs 0.9.0 → 0.9.2

data/lib/parallel_specs/cli.rb

@@ -1,31 +1,38 @@
 # frozen_string_literal: true
 
-require 'optparse'
-require 'fileutils'
-require 'pathname'
-require 'shellwords'
-require 'tmpdir'
+require "optparse"
+require "fileutils"
+require "pathname"
+require "shellwords"
+require "tmpdir"
 
-require 'parallel_specs'
-require 'parallel_specs/cli/dashboard'
-require 'parallel_specs/rspec/runner'
+require "parallel_specs"
+require "parallel_specs/cli/dashboard"
+require "parallel_specs/rspec/runner"
 
 module ParallelSpecs
   class CLI
+    DEFAULT_RERUN_COMMAND_SPEC_FILE_LIMIT = 25
+    DEFAULT_RERUN_COMMAND_CHAR_LIMIT = 2_000
+
     def initialize
       @runner = ParallelSpecs::RSpec::Runner
     end
 
     def run(argv)
-      Signal.trap('INT') { handle_interrupt }
+      Signal.trap("INT") { handle_interrupt }
 
       options = parse_options!(argv)
-      ENV['DISABLE_SPRING'] ||= '1'
+      ENV["DISABLE_SPRING"] ||= "1"
 
       num_processes = ParallelSpecs.determine_number_of_processes(options[:count])
-      abort 'Process count must be greater than 0' unless num_processes.positive?
+      abort "Process count must be greater than 0" unless num_processes.positive?
 
       run_tests_in_parallel(num_processes, options)
+    rescue ParallelSpecs::ConfigurationError => e
+      abort e.message
+    rescue ParallelSpecs::Test::Runner::MissingTestFileError => e
+      abort e.message
     end
 
     private
@@ -137,7 +144,7 @@ module ParallelSpecs
       runtime_log = options[:runtime_log] || @runner.runtime_log
       should_merge_runtime_logs = false
 
-      Dir.mktmpdir('parallel_specs-runtime') do |dir|
+      Dir.mktmpdir("parallel_specs-runtime") do |dir|
         runtime_log_files = groups.each_index.to_h do |index|
           [index, File.join(dir, "worker-#{index + 1}.log")]
         end
@@ -162,13 +169,13 @@ module ParallelSpecs
 
       missing_logs = runtime_log_files.values.reject { |path| File.file?(path) }
       unless missing_logs.empty?
-        warn "parallel_specs: not updating runtime log #{runtime_log}; missing worker runtime logs: #{missing_logs.join(', ')}"
+        warn "parallel_specs: not updating runtime log #{runtime_log}; missing worker runtime logs: #{missing_logs.join(", ")}"
         return false
       end
 
       FileUtils.mkdir_p(File.dirname(runtime_log))
       temporary_runtime_log = "#{runtime_log}.#{Process.pid}.tmp"
-      File.open(temporary_runtime_log, 'w') do |output|
+      File.open(temporary_runtime_log, "w") do |output|
         runtime_log_files.each_value do |path|
           File.foreach(path) { |line| output.write(line) }
         end
@@ -182,10 +189,10 @@ module ParallelSpecs
     def with_dashboard(groups, options)
       return yield unless options[:dashboard]
 
-      Dir.mktmpdir('parallel_specs-dashboard') do |dir|
+      Dir.mktmpdir("parallel_specs-dashboard") do |dir|
         event_files = groups.each_index.to_h do |index|
           path = File.join(dir, "worker-#{index + 1}.jsonl")
-          File.write(path, '')
+          File.write(path, "")
           [index, path]
         end
 
@@ -193,7 +200,7 @@ module ParallelSpecs
         options[:dashboard_runner] = ParallelSpecs::CLI::Dashboard.new(
           groups: groups,
           event_files: event_files,
-          mode: dashboard_mode,
+          mode: dashboard_mode(options),
           use_colors: use_colors?
         )
 
@@ -216,8 +223,8 @@ module ParallelSpecs
 
       puts "\nFailed worker output:\n"
       failures.each do |result|
-        worker_label = result.dig(:env, 'TEST_ENV_NUMBER')
-        worker_label = '1' if worker_label.to_s.empty?
+        worker_label = result.dig(:env, "TEST_ENV_NUMBER")
+        worker_label = "1" if worker_label.to_s.empty?
         puts "--- worker #{worker_label} ---"
         puts result[:stdout]
       end
@@ -227,18 +234,79 @@ module ParallelSpecs
       failures = test_results.reject { |result| result[:exit_status].zero? }
       return if failures.empty?
 
-      puts "\nRerun failed worker commands:\n"
-      failures.each do |result|
-        command = @runner.rerun_command(result[:command], seed: result[:seed])
-        @runner.print_command(command, result[:env] || {})
+      rerun_commands = failures.map do |result|
+        {result: result, command: @runner.rerun_command(result[:command], seed: result[:seed])}
+      end
+
+      if print_full_rerun_commands?(rerun_commands)
+        puts "\nRerun failed worker commands:\n"
+        rerun_commands.each do |entry|
+          @runner.print_command(entry[:command], entry[:result][:env] || {})
+        end
+      else
+        report_failure_rerun_command_summary(rerun_commands)
+      end
+    end
+
+    def print_full_rerun_commands?(rerun_commands)
+      return true if truthy_env?("PARALLEL_SPECS_FULL_RERUN_COMMANDS")
+
+      rerun_commands.all? do |entry|
+        rerun_command_spec_file_count(entry[:command]) <= rerun_command_spec_file_limit &&
+          rerun_command_length(entry[:command], entry[:result][:env] || {}) <= rerun_command_char_limit
+      end
+    end
+
+    def report_failure_rerun_command_summary(rerun_commands)
+      total_spec_files = rerun_commands.sum { |entry| rerun_command_spec_file_count(entry[:command]) }
+
+      puts "\nFull worker rerun commands omitted to keep failure output readable."
+      puts "#{pluralize(rerun_commands.size, "failed worker")} included #{pluralize(total_spec_files, @runner.test_file_name)}."
+      puts "RSpec failure output above includes failed example locations."
+      puts "Set PARALLEL_SPECS_FULL_RERUN_COMMANDS=1 to print full worker rerun commands."
+
+      rerun_commands.each do |entry|
+        result = entry[:result]
+        worker_label = result.dig(:env, "TEST_ENV_NUMBER")
+        worker_label = "1" if worker_label.to_s.empty?
+        seed = result[:seed] ? ", seed #{result[:seed]}" : ""
+        puts "worker #{worker_label}: #{pluralize(rerun_command_spec_file_count(entry[:command]), @runner.test_file_name)}#{seed}"
       end
     end
 
+    def rerun_command_spec_file_count(command)
+      command.count { |arg| arg.end_with?("_spec.rb") }
+    end
+
+    def rerun_command_length(command, env)
+      rerun_env = env.slice("TEST_ENV_NUMBER", "PARALLEL_SPECS_GROUPS").reject { |_key, value| value.to_s.empty? }
+      env_string = rerun_env.map { |key, value| "#{key}=#{Shellwords.escape(value)}" }.join(" ")
+      [env_string, Shellwords.shelljoin(command)].reject(&:empty?).join(" ").length
+    end
+
+    def rerun_command_spec_file_limit
+      positive_integer_env("PARALLEL_SPECS_RERUN_COMMAND_SPEC_FILE_LIMIT") || DEFAULT_RERUN_COMMAND_SPEC_FILE_LIMIT
+    end
+
+    def rerun_command_char_limit
+      positive_integer_env("PARALLEL_SPECS_RERUN_COMMAND_CHAR_LIMIT") || DEFAULT_RERUN_COMMAND_CHAR_LIMIT
+    end
+
+    def positive_integer_env(name)
+      Integer(ENV.fetch(name, nil)).then { |value| value.positive? ? value : nil }
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def truthy_env?(name)
+      %w[1 true yes].include?(ENV.fetch(name, "").downcase)
+    end
+
     def report_number_of_tests(groups)
       num_processes = groups.size
       num_tests = groups.map(&:size).sum
       tests_per_process = num_processes.zero? ? 0 : num_tests / num_processes
-      puts "#{pluralize(num_processes, 'process')} for #{pluralize(num_tests, @runner.test_file_name)}, ~ #{pluralize(tests_per_process, @runner.test_file_name)} per process"
+      puts "#{pluralize(num_processes, "process")} for #{pluralize(num_tests, @runner.test_file_name)}, ~ #{pluralize(tests_per_process, @runner.test_file_name)} per process"
     end
 
     def any_test_failed?(test_results)
@@ -251,7 +319,8 @@ module ParallelSpecs
 
     def parse_options!(argv)
       newline_padding = 33
-      options = { dashboard: true }
+      options = {dashboard: true}
+      cli_argv, rspec_argv = split_rspec_args(argv)
 
       OptionParser.new do |opts|
         opts.banner = <<~BANNER
@@ -266,48 +335,65 @@ module ParallelSpecs
           Options are:
         BANNER
 
-        opts.on('-n PROCESSES', Integer, 'How many processes to use, default: available CPUs') { |n| options[:count] = n }
-        opts.on('-o', '--test-options OPTIONS', 'Pass these options to rspec') { |arg| options[:test_options] = Shellwords.shellsplit(arg) }
-        opts.on('--group-by TYPE', heredoc(<<~TEXT, newline_padding)) { |type| options[:group_by] = type.to_sym }
+        opts.on("-n PROCESSES", Integer, "How many processes to use, default: available CPUs") { |n| options[:count] = n }
+        opts.on("-o", "--test-options OPTIONS", "Pass these options to rspec") { |arg| options[:test_options] = Shellwords.shellsplit(arg) }
+        opts.on("--group-by TYPE", heredoc(<<~TEXT, newline_padding)) { |type| options[:group_by] = type.to_sym }
           group specs by:
           found - order of finding files
           filesize - by size of the file
           runtime - info from runtime log
           default - runtime when runtime log is filled otherwise filesize
         TEXT
-        opts.on('--pattern PATTERN', 'Only run spec files matching PATTERN') { |pattern| options[:pattern] = Regexp.new(pattern) }
-        opts.on('--exclude-pattern PATTERN', 'Skip spec files matching PATTERN') { |pattern| options[:exclude_pattern] = Regexp.new(pattern) }
-        opts.on('--runtime-log PATH', 'Read spec runtimes from PATH; with --record-runtime, write the completed run there') { |path| options[:runtime_log] = path }
-        opts.on('--allowed-missing COUNT', Integer, 'Allowed percentage of missing runtimes (default = 50)') { |percent| options[:allowed_missing_percent] = percent }
-        opts.on('--unknown-runtime SECONDS', Float, 'Use given number as unknown runtime (otherwise use average time)') { |time| options[:unknown_runtime] = time }
-        opts.on('--record-runtime', 'Record runtimes and replace the runtime log only after a successful complete run') { options[:record_runtime] = true }
-        opts.on('--fail-fast', 'Stop remaining workers after one worker fails') { options[:fail_fast] = true }
-        opts.on('-v', '--version', 'Show version') { puts ParallelSpecs::VERSION; exit 0 }
-        opts.on('-h', '--help', 'Show this help') { puts opts; exit 0 }
-      end.parse!(argv)
-
-      options[:dashboard] = !options[:record_runtime]
-
-      files, remaining = extract_file_paths(argv)
+        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 }
+        opts.on("--pattern PATTERN", "Only run spec files matching PATTERN") { |pattern| options[:pattern] = Regexp.new(pattern) }
+        opts.on("--exclude-pattern PATTERN", "Skip spec files matching PATTERN") { |pattern| options[:exclude_pattern] = Regexp.new(pattern) }
+        opts.on("--runtime-log PATH", "Read spec runtimes from PATH; with --record-runtime, write the completed run there") { |path| options[:runtime_log] = path }
+        opts.on("--allowed-missing COUNT", Integer, "Allowed percentage of missing runtimes (default = 50)") { |percent| options[:allowed_missing_percent] = percent }
+        opts.on("--unknown-runtime SECONDS", Float, "Use given number as unknown runtime (otherwise use average time)") { |time| options[:unknown_runtime] = time }
+        opts.on("--record-runtime", "Record runtimes and replace the runtime log only after a successful complete run") { options[:record_runtime] = true }
+        opts.on("--fail-fast", "Stop remaining workers after one worker fails") { options[:fail_fast] = true }
+        opts.on("-v", "--version", "Show version") {
+          puts ParallelSpecs::VERSION
+          exit 0
+        }
+        opts.on("-h", "--help", "Show this help") {
+          puts opts
+          exit 0
+        }
+      end.parse!(cli_argv)
+
+      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 }
       append_test_options(options, remaining)
       options
     end
 
-    def extract_file_paths(argv)
-      dash_index = argv.rindex('--')
-      file_args_at = (dash_index || -1) + 1
-      [argv[file_args_at..], argv[0...(dash_index || 0)]]
+    def split_rspec_args(argv)
+      dash_index = argv.index("--")
+      return [argv, []] unless dash_index
+
+      [argv[0...dash_index], argv[(dash_index + 1)..]]
     end
 
-    def extract_test_options(argv)
-      dash_index = argv.index('--') || -1
-      argv[dash_index + 1..]
+    def extract_file_paths(argv, rspec_argv)
+      dash_index = rspec_argv.index("--")
+      return [argv, rspec_argv] unless dash_index
+
+      [argv + rspec_argv[(dash_index + 1)..], rspec_argv[0...dash_index]]
     end
 
     def append_test_options(options, argv)
-      new_opts = extract_test_options(argv)
+      new_opts = argv
       return if new_opts.empty?
 
       options[:test_options] ||= []
@@ -316,18 +402,18 @@ module ParallelSpecs
 
     def report_time_taken(&block)
       seconds = ParallelSpecs.delta(&block).to_i
-      puts "\nTook #{pluralize(seconds, 'second')}#{detailed_duration(seconds)}"
+      puts "\nTook #{pluralize(seconds, "second")}#{detailed_duration(seconds)}"
     end
 
     def detailed_duration(seconds)
       parts = [seconds / 3600, (seconds % 3600) / 60, seconds % 60].drop_while(&:zero?)
       return if parts.size < 2
 
-      " (#{parts.map { |part| format('%02d', part) }.join(':').sub(/^0/, '')})"
+      " (#{parts.map { |part| format("%02d", part) }.join(":").sub(/^0/, "")})"
     end
 
     def final_fail_message
-      message = 'Specs Failed'
+      message = "Specs Failed"
       use_colors? ? "\e[31m#{message}\e[0m" : message
     end
 
@@ -339,11 +425,13 @@ module ParallelSpecs
       options[:dashboard_runner]&.plain?
     end
 
-    def dashboard_mode
-      override = ENV['PARALLEL_SPECS_DASHBOARD_MODE']
+    def dashboard_mode(options = {})
+      return options[:dashboard_mode] if options[:dashboard_mode]
+
+      override = ENV["PARALLEL_SPECS_DASHBOARD_MODE"]
       return override.to_sym if %w[interactive plain].include?(override)
 
-      if ENV['CI'] || !$stdout.tty?
+      if ENV["CI"] || !$stdout.tty?
         :plain
       else
         :interactive
@@ -354,10 +442,10 @@ module ParallelSpecs
       return yield unless simulate
 
       progress_indicator = Thread.new do
-        interval = Float(ENV['PARALLEL_SPECS_HEARTBEAT_INTERVAL'] || 60)
+        interval = Float(ENV["PARALLEL_SPECS_HEARTBEAT_INTERVAL"] || 60)
         loop do
           sleep interval
-          $stdout.print '.'
+          $stdout.print "."
           $stdout.flush
         end
       end
@@ -368,12 +456,12 @@ module ParallelSpecs
     end
 
     def heredoc(text, newline_padding)
-      text.rstrip.gsub("\n", "\n#{' ' * newline_padding}")
+      text.rstrip.gsub("\n", "\n#{" " * newline_padding}")
     end
 
     def pluralize(number, singular)
       return "1 #{singular}" if number == 1
-      return "#{number} #{singular}es" if singular.end_with?('s', 'sh', 'ch', 'x', 'z')
+      return "#{number} #{singular}es" if singular.end_with?("s", "sh", "ch", "x", "z")
 
       "#{number} #{singular}s"
     end

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 = {})
-        groups = Array.new(num_groups) { { items: [], size: 0 } }
+      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/pids.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module ParallelSpecs
   class Pids

data/lib/parallel_specs/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "parallel_specs"
+
+module ParallelSpecs
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      require "parallel_specs/tasks"
+    end
+  end
+end

data/lib/parallel_specs/rspec/dashboard_logger.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'json'
-require 'rspec/core'
-require 'rspec/core/formatters/base_text_formatter'
+require "fileutils"
+require "json"
+require "rspec/core"
+require "rspec/core/formatters/base_text_formatter"
 
 module ParallelSpecs
   module RSpec
@@ -23,32 +23,32 @@ class ParallelSpecs::RSpec::DashboardLogger < RSpec::Core::Formatters::BaseTextF
   def initialize(output)
     super
 
-    path = ENV['PARALLEL_SPECS_DASHBOARD_EVENT_LOG']
-    raise 'A dashboard event log env var is required for DashboardLogger' if path.to_s.empty?
+    path = ENV["PARALLEL_SPECS_DASHBOARD_EVENT_LOG"]
+    raise "A dashboard event log env var is required for DashboardLogger" if path.to_s.empty?
 
     FileUtils.mkdir_p(File.dirname(path))
-    @event_output = File.open(path, 'a')
+    @event_output = File.open(path, "a")
     @event_output.sync = true
   end
 
   def start(notification)
-    emit(event: 'start', total: notification.count)
+    emit(event: "start", total: notification.count)
   end
 
   def example_started(notification)
-    emit_example('example_started', notification)
+    emit_example("example_started", notification)
   end
 
   def example_passed(notification)
-    emit_example('example_passed', notification)
+    emit_example("example_passed", notification)
   end
 
   def example_pending(notification)
-    emit_example('example_pending', notification)
+    emit_example("example_pending", notification)
   end
 
   def example_failed(notification)
-    emit_example('example_failed', notification)
+    emit_example("example_failed", notification)
   end
 
   def close(*)

data/lib/parallel_specs/rspec/logger_base.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'rspec/core'
-require 'rspec/core/formatters/base_text_formatter'
+require "fileutils"
+require "rspec/core"
+require "rspec/core/formatters/base_text_formatter"
 
 module ParallelSpecs
   module RSpec
@@ -17,11 +17,11 @@ class ParallelSpecs::RSpec::LoggerBase < RSpec::Core::Formatters::BaseTextFormat
     case @output
     when String
       FileUtils.mkdir_p(File.dirname(@output))
-      File.open(@output, 'w') {}
-      @output = File.open(@output, 'a')
+      File.open(@output, "w") {}
+      @output = File.open(@output, "a")
     when File
       @output.close
-      @output = File.open(@output.path, 'a')
+      @output = File.open(@output.path, "a")
     end
   end
 

data/lib/parallel_specs/rspec/runner.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'parallel_specs/test/runner'
+require "parallel_specs/test/runner"
 
 module ParallelSpecs
   module RSpec
@@ -16,15 +16,15 @@ module ParallelSpecs
         end
 
         def runtime_log
-          'tmp/parallel_runtime_rspec.log'
+          "tmp/parallel_runtime_rspec.log"
         end
 
         def default_test_folder
-          'spec'
+          "spec"
         end
 
         def test_file_name
-          'spec'
+          "spec"
         end
 
         def line_is_result?(line)
@@ -36,9 +36,9 @@ module ParallelSpecs
           return text unless $stdout.tty?
 
           sums = send(:sum_up_results, results)
-          color_code = if sums['failure'] > 0
+          color_code = if sums["failure"] > 0
             31
-          elsif sums['pending'] > 0
+          elsif sums["pending"] > 0
             33
           else
             32
@@ -52,7 +52,7 @@ module ParallelSpecs
         end
 
         def command_with_seed(command, seed)
-          [*remove_command_arguments(command, '--seed', '--order'), '--seed', seed]
+          [*remove_command_arguments(command, "--seed", "--order"), "--seed", seed]
         end
 
         private
@@ -69,17 +69,17 @@ module ParallelSpecs
         end
 
         def remove_rerun_only_formatters(command)
-          remove_formatter(command, 'ParallelSpecs::RSpec::DashboardLogger')
-            .then { |cmd| remove_formatter(cmd, 'ParallelSpecs::RSpec::RuntimeLogger') }
+          remove_formatter(command, "ParallelSpecs::RSpec::DashboardLogger")
+            .then { |cmd| remove_formatter(cmd, "ParallelSpecs::RSpec::RuntimeLogger") }
         end
 
         def remove_formatter(command, formatter)
           cleaned = []
           index = 0
           while index < command.length
-            if command[index] == '--format' && command[index + 1] == formatter
+            if command[index] == "--format" && command[index + 1] == formatter
               index += 2
-            elsif command[index] == '--out' && command[index - 2] == '--format' && command[index - 1] == formatter
+            elsif command[index] == "--out" && command[index - 2] == "--format" && command[index - 1] == formatter
               index += 2
             else
               cleaned << command[index]
@@ -90,12 +90,12 @@ module ParallelSpecs
         end
 
         def executable
-          if File.exist?('bin/rspec')
-            ParallelSpecs.with_ruby_binary('bin/rspec')
+          if File.exist?("bin/rspec")
+            ParallelSpecs.with_ruby_binary("bin/rspec")
           elsif ParallelSpecs.bundler_enabled?
             %w[bundle exec rspec]
           else
-            ['rspec']
+            ["rspec"]
           end
         end
 
@@ -104,7 +104,7 @@ module ParallelSpecs
         end
 
         def dashboard_formatter(options)
-          ['--format', 'ParallelSpecs::RSpec::DashboardLogger'] if options[:dashboard]
+          ["--format", "ParallelSpecs::RSpec::DashboardLogger"] if options[:dashboard]
         end
 
         def record_runtime_formatters(process_number, options)
@@ -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