parallel_tests 3.4.0 → 4.3.0

data/lib/parallel_tests/tasks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rake'
 require 'shellwords'
 
@@ -8,16 +9,8 @@ module ParallelTests
         'test'
       end
 
-      def rake_bin
-        # Prevent 'Exec format error' Errno::ENOEXEC on Windows
-        return "rake" if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
-        binstub_path = File.join('bin', 'rake')
-        return binstub_path if File.exist?(binstub_path)
-        "rake"
-      end
-
       def load_lib
-        $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+        $LOAD_PATH << File.expand_path('..', __dir__)
         require "parallel_tests"
       end
 
@@ -27,13 +20,17 @@ module ParallelTests
         end
       end
 
-      def run_in_parallel(cmd, options={})
+      def run_in_parallel(cmd, options = {})
         load_lib
-        count = " -n #{options[:count]}" unless options[:count].to_s.empty?
+
         # Using the relative path to find the binary allow to run a specific version of it
-        executable = File.expand_path("../../../bin/parallel_test", __FILE__)
-        command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} --exec '#{cmd}'#{count}#{' --non-parallel' if options[:non_parallel]}"
-        abort unless system(command)
+        executable = File.expand_path('../../bin/parallel_test', __dir__)
+        command = ParallelTests.with_ruby_binary(executable)
+        command += ['--exec', Shellwords.join(cmd)]
+        command += ['-n', options[:count]] unless options[:count].to_s.empty?
+        command << '--non-parallel' if options[:non_parallel]
+
+        abort unless system(*command)
       end
 
       # this is a crazy-complex solution for a very simple problem:
@@ -46,16 +43,14 @@ module ParallelTests
       # - pipefail makes pipe fail with exitstatus of first failed command
       # - pipefail is not supported in (zsh)
       # - defining a new rake task like silence_schema would force users to load parallel_tests in test env
-      # - do not use ' since run_in_parallel uses them to quote stuff
       # - simple system "set -o pipefail" returns nil even though set -o pipefail exists with 0
       def suppress_output(command, ignore_regex)
         activate_pipefail = "set -o pipefail"
-        remove_ignored_lines = %Q{(grep -v "#{ignore_regex}" || test 1)}
+        remove_ignored_lines = %{(grep -v #{Shellwords.escape(ignore_regex)} || true)}
 
-        if File.executable?('/bin/bash') && system('/bin/bash', '-c', "#{activate_pipefail} 2>/dev/null && test 1")
-          # We need to shell escape single quotes (' becomes '"'"') because
-          # run_in_parallel wraps command in single quotes
-          %Q{/bin/bash -c '"'"'#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}'"'"'}
+        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
@@ -83,12 +78,61 @@ module ParallelTests
         # parallel:spec[2,models,options]
         # parallel:spec[,models,options]
         count = args.shift if args.first.to_s =~ /^\d*$/
-        num_processes = count.to_i unless count.to_s.empty?
+        num_processes = (count.to_s.empty? ? nil : Integer(count))
         pattern = args.shift
         options = args.shift
         pass_through = args.shift
 
-        [num_processes, pattern.to_s, options.to_s, pass_through.to_s]
+        [num_processes, pattern, options, pass_through]
+      end
+
+      def schema_format_based_on_rails_version
+        if rails_7_or_greater?
+          ActiveRecord.schema_format
+        else
+          ActiveRecord::Base.schema_format
+        end
+      end
+
+      def schema_type_based_on_rails_version
+        if rails_61_or_greater? || schema_format_based_on_rails_version == :ruby
+          "schema"
+        else
+          "structure"
+        end
+      end
+
+      def build_run_command(type, args)
+        count, pattern, options, pass_through = ParallelTests::Tasks.parse_args(args)
+        test_framework = {
+          'spec' => 'rspec',
+          'test' => 'test',
+          'features' => 'cucumber',
+          'features-spinach' => 'spinach'
+        }.fetch(type)
+
+        type = 'features' if test_framework == 'spinach'
+
+        # Using the relative path to find the binary allow to run a specific version of it
+        executable = File.expand_path('../../bin/parallel_test', __dir__)
+        executable = ParallelTests.with_ruby_binary(executable)
+
+        command = [*executable, type, '--type', test_framework]
+        command += ['-n', count.to_s] if count
+        command += ['--pattern', pattern] if pattern
+        command += ['--test-options', options] if options
+        command += Shellwords.shellsplit pass_through if pass_through
+        command
+      end
+
+      private
+
+      def rails_7_or_greater?
+        Gem::Version.new(Rails.version) >= Gem::Version.new('7.0')
+      end
+
+      def rails_61_or_greater?
+        Gem::Version.new(Rails.version) >= Gem::Version.new('6.1.0')
       end
     end
   end
@@ -96,30 +140,40 @@ end
 
 namespace :parallel do
   desc "Setup test databases via db:setup --> parallel:setup[num_cpus]"
-  task :setup, :count do |_,args|
-    command = "#{ParallelTests::Tasks.rake_bin} db:setup RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+  task :setup, :count do |_, args|
+    command = [$0, "db:setup", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"]
     ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
   end
 
   desc "Create test databases via db:create --> parallel:create[num_cpus]"
-  task :create, :count do |_,args|
+  task :create, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      [$0, "db:create", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
+    )
   end
 
   desc "Drop test databases via db:drop --> parallel:drop[num_cpus]"
-  task :drop, :count do |_,args|
+  task :drop, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env} " \
-      "DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args)
+      [
+        $0,
+        "db:drop",
+        "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
+        "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      ],
+      args
+    )
   end
 
   desc "Update test databases by dumping and loading --> parallel:prepare[num_cpus]"
-  task(:prepare, [:count]) do |_,args|
+  task(:prepare, [:count]) do |_, args|
     ParallelTests::Tasks.check_for_pending_migrations
-    if defined?(ActiveRecord::Base) && [:ruby, :sql].include?(ActiveRecord::Base.schema_format)
+
+    if defined?(ActiveRecord) && [:ruby, :sql].include?(ParallelTests::Tasks.schema_format_based_on_rails_version)
       # fast: dump once, load in parallel
-      type = (ActiveRecord::Base.schema_format == :ruby ? "schema" : "structure")
+      type = ParallelTests::Tasks.schema_type_based_on_rails_version
+
       Rake::Task["db:#{type}:dump"].invoke
 
       # remove database connection to prevent "database is being accessed by other users"
@@ -128,82 +182,87 @@ namespace :parallel do
       Rake::Task["parallel:load_#{type}"].invoke(args[:count])
     else
       # slow: dump and load in in serial
-      args = args.to_hash.merge(:non_parallel => true) # normal merge returns nil
+      args = args.to_hash.merge(non_parallel: true) # normal merge returns nil
       task_name = Rake::Task.task_defined?('db:test:prepare') ? 'db:test:prepare' : 'app:db:test:prepare'
-      ParallelTests::Tasks.run_in_parallel("#{ParallelTests::Tasks.rake_bin} #{task_name}", args)
+      ParallelTests::Tasks.run_in_parallel([$0, task_name], args)
       next
     end
   end
 
   # when dumping/resetting takes too long
   desc "Update test databases via db:migrate --> parallel:migrate[num_cpus]"
-  task :migrate, :count do |_,args|
+  task :migrate, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      [$0, "db:migrate", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
+    )
   end
 
   desc "Rollback test databases via db:rollback --> parallel:rollback[num_cpus]"
-  task :rollback, :count do |_,args|
+  task :rollback, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:rollback RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      [$0, "db:rollback", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
+    )
   end
 
   # just load the schema (good for integration server <-> no development db)
   desc "Load dumped schema for test databases via db:schema:load --> parallel:load_schema[num_cpus]"
-  task :load_schema, :count do |_,args|
-    command = "#{ParallelTests::Tasks.rake_bin} #{ParallelTests::Tasks.purge_before_load} " \
-      "db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+  task :load_schema, :count do |_, args|
+    command = [
+      $0,
+      ParallelTests::Tasks.purge_before_load,
+      "db:schema:load",
+      "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
+      "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+    ]
     ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
   end
 
   # load the structure from the structure.sql file
-  desc "Load structure for test databases via db:structure:load --> parallel:load_structure[num_cpus]"
-  task :load_structure, :count do |_,args|
+  # (faster for rails < 6.1, deprecated after and only configured by `ActiveRecord::Base.schema_format`)
+  desc "Load structure for test databases via db:schema:load --> parallel:load_structure[num_cpus]"
+  task :load_structure, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} #{ParallelTests::Tasks.purge_before_load} " \
-      "db:structure:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args)
+      [
+        $0,
+        ParallelTests::Tasks.purge_before_load,
+        "db:structure:load",
+        "RAILS_ENV=#{ParallelTests::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]"
-  task :seed, :count do |_,args|
+  task :seed, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      [
+        $0,
+        "db:seed",
+        "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+      ],
+      args
+    )
   end
 
   desc "Launch given rake command in parallel"
   task :rake, :command, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "RAILS_ENV=#{ParallelTests::Tasks.rails_env} #{ParallelTests::Tasks.rake_bin} " \
-      "#{args.command}", args)
+      [$0, args.command, "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
+    )
   end
 
   ['test', 'spec', 'features', 'features-spinach'].each do |type|
     desc "Run #{type} in parallel with parallel:#{type}[num_cpus]"
-    task type, [:count, :pattern, :options, :pass_through] do |t, args|
+    task type, [:count, :pattern, :options, :pass_through] do |_t, args|
       ParallelTests::Tasks.check_for_pending_migrations
       ParallelTests::Tasks.load_lib
+      command = ParallelTests::Tasks.build_run_command(type, args)
 
-      count, pattern, options, pass_through = ParallelTests::Tasks.parse_args(args)
-      test_framework = {
-        'spec' => 'rspec',
-        'test' => 'test',
-        'features' => 'cucumber',
-        'features-spinach' => 'spinach',
-      }[type]
-
-      if test_framework == 'spinach'
-        type = 'features'
-      end
-      # Using the relative path to find the binary allow to run a specific version of it
-      executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
-
-      command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} #{type} " \
-        "--type #{test_framework} "        \
-        "-n #{count} "                     \
-        "--pattern '#{pattern}' "          \
-        "--test-options '#{options}' "     \
-        "#{pass_through}"
-      abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+      abort unless system(*command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end
 end

data/lib/parallel_tests/test/runner.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+require 'shellwords'
 require 'parallel_tests'
 
 module ParallelTests
   module Test
     class Runner
+      RuntimeLogTooSmallError = Class.new(StandardError)
+
       class << self
         # --- usually overwritten by other runners
 
@@ -14,13 +18,24 @@ module ParallelTests
           /_(test|spec).rb$/
         end
 
+        def default_test_folder
+          "test"
+        end
+
         def test_file_name
           "test"
         end
 
         def run_tests(test_files, process_number, num_processes, options)
-          require_list = test_files.map { |file| file.sub(" ", "\\ ") }.join(" ")
-          cmd = "#{executable} -Itest -e '%w[#{require_list}].each { |f| require %{./\#{f}} }' -- #{options[:test_options]}"
+          require_list = test_files.map { |file| file.gsub(" ", "\\ ") }.join(" ")
+          cmd = [
+            *executable,
+            '-Itest',
+            '-e',
+            "%w[#{require_list}].each { |f| require %{./\#{f}} }",
+            '--',
+            *options[:test_options]
+          ]
           execute_command(cmd, process_number, num_processes, options)
         end
 
@@ -32,7 +47,7 @@ module ParallelTests
         # --- usually used by other runners
 
         # finds all tests and partitions them into groups
-        def tests_in_groups(tests, num_groups, options={})
+        def tests_in_groups(tests, num_groups, options = {})
           tests = tests_with_size(tests, options)
           Grouper.in_even_groups_by_size(tests, num_groups, options)
         end
@@ -46,12 +61,19 @@ module ParallelTests
           when :filesize
             sort_by_filesize(tests)
           when :runtime
-            sort_by_runtime(tests, runtimes(tests, options), options.merge(allowed_missing: (options[:allowed_missing_percent] || 50) / 100.0))
+            sort_by_runtime(
+              tests, runtimes(tests, options),
+              options.merge(allowed_missing: (options[:allowed_missing_percent] || 50) / 100.0)
+            )
           when nil
             # use recorded test runtime if we got enough data
-            runtimes = runtimes(tests, options) rescue []
+            runtimes = begin
+              runtimes(tests, options)
+            rescue StandardError
+              []
+            end
             if runtimes.size * 1.5 > tests.size
-              puts "Using recorded test runtime"
+              puts "Using recorded test runtime" unless options[:quiet]
               sort_by_runtime(tests, runtimes)
             else
               sort_by_filesize(tests)
@@ -64,35 +86,44 @@ module ParallelTests
         end
 
         def execute_command(cmd, process_number, num_processes, options)
+          number = test_env_number(process_number, options).to_s
           env = (options[:env] || {}).merge(
-            "TEST_ENV_NUMBER" => test_env_number(process_number, options).to_s,
+            "TEST_ENV_NUMBER" => number,
             "PARALLEL_TEST_GROUPS" => num_processes.to_s,
-            "PARALLEL_PID_FILE" => ParallelTests.pid_file_path,
+            "PARALLEL_PID_FILE" => ParallelTests.pid_file_path
           )
-          cmd = "nice #{cmd}" if options[:nice]
-          cmd = "#{cmd} 2>&1" if options[:combine_stderr]
+          cmd = ["nice", *cmd] if options[:nice]
 
-          puts cmd if report_process_command?(options) && !options[:serialize_stdout]
+          # being able to run with for example `-output foo-$TEST_ENV_NUMBER` worked originally and is convenient
+          cmd = cmd.map { |c| c.gsub("$TEST_ENV_NUMBER", number).gsub("${TEST_ENV_NUMBER}", number) }
+
+          print_command(cmd, env) if report_process_command?(options) && !options[:serialize_stdout]
 
           execute_command_and_capture_output(env, cmd, options)
         end
 
+        def print_command(command, env)
+          env_str = ['TEST_ENV_NUMBER', 'PARALLEL_TEST_GROUPS'].map { |e| "#{e}=#{env[e]}" }.join(' ')
+          puts [env_str, Shellwords.shelljoin(command)].compact.join(' ')
+        end
+
         def execute_command_and_capture_output(env, cmd, options)
+          popen_options = {} # do not add `pgroup: true`, it will break `binding.irb` inside the test
+          popen_options[:err] = [:child, :out] if options[:combine_stderr]
+
           pid = nil
-          output = IO.popen(env, cmd) do |io|
+          output = IO.popen(env, cmd, popen_options) do |io|
             pid = io.pid
             ParallelTests.pids.add(pid)
             capture_output(io, env, options)
           end
           ParallelTests.pids.delete(pid) if pid
           exitstatus = $?.exitstatus
-          seed = output[/seed (\d+)/,1]
+          seed = output[/seed (\d+)/, 1]
 
-          if report_process_command?(options) && options[:serialize_stdout]
-            output = [cmd, output].join("\n")
-          end
+          output = "#{Shellwords.shelljoin(cmd)}\n#{output}" if report_process_command?(options) && options[:serialize_stdout]
 
-          {:stdout => output, :exit_status => exitstatus, :command => cmd, :seed => seed}
+          { env: env, stdout: output, exit_status: exitstatus, command: cmd, seed: seed }
         end
 
         def find_results(test_output)
@@ -104,7 +135,7 @@ module ParallelTests
           end.compact
         end
 
-        def test_env_number(process_number, options={})
+        def test_env_number(process_number, options = {})
           if process_number == 0 && !options[:first_is_1]
             ''
           else
@@ -114,39 +145,42 @@ module ParallelTests
 
         def summarize_results(results)
           sums = sum_up_results(results)
-          sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+          sums.sort.map { |word, number| "#{number} #{word}#{'s' if number != 1}" }.join(', ')
         end
 
         # remove old seed and add new seed
         def command_with_seed(cmd, seed)
-          clean = cmd.sub(/\s--seed\s+\d+\b/, '')
-          "#{clean} --seed #{seed}"
+          clean = remove_command_arguments(cmd, '--seed')
+          [*clean, '--seed', seed]
         end
 
         protected
 
         def executable
-          ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
+          if (executable = ENV['PARALLEL_TESTS_EXECUTABLE'])
+            [executable]
+          else
+            determine_executable
+          end
         end
 
         def determine_executable
-          "ruby"
+          ["ruby"]
         end
 
         def sum_up_results(results)
-          results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
+          results = results.join(' ').gsub(/s\b/, '') # combine and singularize results
           counts = results.scan(/(\d+) (\w+)/)
-          counts.inject(Hash.new(0)) do |sum, (number, word)|
+          counts.each_with_object(Hash.new(0)) do |(number, word), sum|
             sum[word] += number.to_i
-            sum
           end
         end
 
         # read output of the process and print it in chunks
-        def capture_output(out, env, options={})
-          result = ""
-          loop do
-            begin
+        def capture_output(out, env, options = {})
+          result = +""
+          begin
+            loop do
               read = out.readpartial(1000000) # read whatever chunk we can get
               if Encoding.default_internal
                 read = read.force_encoding(Encoding.default_internal)
@@ -159,11 +193,13 @@ module ParallelTests
                 $stdout.flush
               end
             end
-          end rescue EOFError
+          rescue EOFError
+            nil
+          end
           result
         end
 
-        def sort_by_runtime(tests, runtimes, options={})
+        def sort_by_runtime(tests, runtimes, options = {})
           allowed_missing = options[:allowed_missing] || 1.0
           allowed_missing = tests.size * allowed_missing
 
@@ -173,14 +209,12 @@ module ParallelTests
             allowed_missing -= 1 unless time = runtimes[test]
             if allowed_missing < 0
               log = options[:runtime_log] || runtime_log
-              raise "Runtime log file '#{log}' does not contain sufficient data to sort #{tests.size} test files, please update or remove it."
+              raise RuntimeLogTooSmallError, "Runtime log file '#{log}' does not contain sufficient data to sort #{tests.size} test files, please update or remove it."
             end
             [test, time]
           end
 
-          if options[:verbose]
-            puts "Runtime found for #{tests.count(&:last)} of #{tests.size} tests"
-          end
+          puts "Runtime found for #{tests.count(&:last)} of #{tests.size} tests" if options[:verbose]
 
           set_unknown_runtime tests, options
         end
@@ -190,7 +224,7 @@ module ParallelTests
           lines = File.read(log).split("\n")
           lines.each_with_object({}) do |line, times|
             test, _, time = line.rpartition(':')
-            next unless test and time
+            next unless test && time
             times[test] = time.to_f if tests.include?(test)
           end
         end
@@ -217,7 +251,7 @@ module ParallelTests
           end.uniq
         end
 
-        def files_in_folder(folder, options={})
+        def files_in_folder(folder, options = {})
           pattern = if options[:symlinks] == false # not nil or true
             "**/*"
           else
@@ -225,7 +259,22 @@ module ParallelTests
             # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
             "**{,/*/**}/*"
           end
-          Dir[File.join(folder, pattern)].uniq
+          Dir[File.join(folder, pattern)].uniq.sort
+        end
+
+        def remove_command_arguments(command, *args)
+          remove_next = false
+          command.select do |arg|
+            if remove_next
+              remove_next = false
+              false
+            elsif args.include?(arg)
+              remove_next = true
+              false
+            else
+              true
+            end
+          end
         end
 
         private
@@ -236,12 +285,12 @@ module ParallelTests
           known, unknown = tests.partition(&:last)
           return if unknown.empty?
           unknown_runtime = options[:unknown_runtime] ||
-            (known.empty? ? 1 : known.map!(&:last).inject(:+) / known.size) # average
+            (known.empty? ? 1 : known.map!(&:last).sum / known.size) # average
           unknown.each { |set| set[1] = unknown_runtime }
         end
 
         def report_process_command?(options)
-          options[:verbose] || options[:verbose_process_command]
+          options[:verbose] || options[:verbose_command]
         end
       end
     end

data/lib/parallel_tests/test/runtime_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 require 'parallel_tests/test/runner'
 
@@ -22,7 +23,7 @@ module ParallelTests
             separator = "\n"
             groups = logfile.read.split(separator).map { |line| line.split(":") }.group_by(&:first)
             lines = groups.map do |file, times|
-              time = "%.2f" % times.map(&:last).map(&:to_f).inject(:+)
+              time = "%.2f" % times.map(&:last).map(&:to_f).sum
               "#{file}:#{time}"
             end
             logfile.rewind
@@ -34,7 +35,7 @@ module ParallelTests
         private
 
         def with_locked_log
-          File.open(logfile, File::RDWR|File::CREAT) do |logfile|
+          File.open(logfile, File::RDWR | File::CREAT) do |logfile|
             logfile.flock(File::LOCK_EX)
             yield logfile
           end
@@ -59,7 +60,7 @@ module ParallelTests
         end
 
         def message(test, delta)
-          return unless method = test.public_instance_methods(true).detect { |method| method =~ /^test_/ }
+          return unless method = test.public_instance_methods(true).detect { |m| m =~ /^test_/ }
           filename = test.instance_method(method).source_location.first.sub("#{Dir.pwd}/", "")
           "#{filename}:#{delta}"
         end
@@ -74,22 +75,26 @@ end
 
 if defined?(Minitest::Runnable) # Minitest 5
   class << Minitest::Runnable
-    prepend(Module.new do
-      def run(*)
-        ParallelTests::Test::RuntimeLogger.log_test_run(self) do
-          super
+    prepend(
+      Module.new do
+        def run(*)
+          ParallelTests::Test::RuntimeLogger.log_test_run(self) do
+            super
+          end
         end
       end
-    end)
+    )
   end
 
   class << Minitest
-    prepend(Module.new do
-      def run(*args)
-        result = super
-        ParallelTests::Test::RuntimeLogger.unique_log
-        result
+    prepend(
+      Module.new do
+        def run(*args)
+          result = super
+          ParallelTests::Test::RuntimeLogger.unique_log
+          result
+        end
       end
-    end)
+    )
   end
 end

data/lib/parallel_tests/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
-  VERSION = Version = '3.4.0'
+  VERSION = '4.3.0'
 end