rspec-parallel 2.14.8.1 → 2.14.8.2

data/lib/rspec/parallel/example_group_thread_runner.rb

@@ -1,49 +1,49 @@
-module RSpec
-  module Parallel
-    # ExampleGroupThreadRunner is a class used to execute [ExampleGroup] 
-    # classes in parallel as part of rspec-core.  When running in parallel 
-    # the order of example groups will not be honoured.  
-    # This class is used to ensure that we have a way of keeping track of
-    # the number of threads being created and preventing utilization of
-    # more than the specified number
-    # Additionally, this class will contain a mutex used to prevent access
-    # to shared variables within sub-threads
-    class ExampleGroupThreadRunner
-      attr_accessor :thread_array, :max_threads, :mutex, :used_threads
-
-      # Creates a new instance of ExampleGroupThreadRunner.
-      # @param max_threads [Integer] the maximum limit of threads that can be used
-      # @param mutex [Mutex] a semaphore used to prevent access to shared variables in
-      # sub-threads such as those used by [ExampleThreadRunner]
-      # @param used_threads [Integer] the current number of threads being used
-      def initialize(max_threads = 1, mutex = Mutex.new, used_threads = 0)
-        @max_threads = max_threads
-        @mutex = mutex
-        @used_threads = used_threads
-        @thread_array = []
-      end
-
-      # Method will run an [ExampleGroup] inside a [Thread] to prevent blocking
-      # execution.  The new [Thread] is added to an array for tracking and
-      # will automatically remove itself when done
-      # @param example_group [ExampleGroup] the group to be run inside a [Thread]
-      # @param reporter [Reporter] the passed in reporting class used for 
-      # tracking
-      def run(example_group, reporter)
-        @thread_array.push Thread.start {
-          example_group.run_parallel(reporter, @max_threads, @mutex, @used_threads)
-          @thread_array.delete Thread.current
-        }
-      end
-
-      # Method will wait for all threads to complete.  On completion threads
-      # remove themselves from the @thread_array so an empty array means they
-      # completed
-      def wait_for_completion
-        @thread_array.each do |t|
-          t.join
-        end
-      end
-    end
-  end
-end
+module RSpec
+  module Parallel
+    # ExampleGroupThreadRunner is a class used to execute [ExampleGroup] 
+    # classes in parallel as part of rspec-core.  When running in parallel 
+    # the order of example groups will not be honoured.  
+    # This class is used to ensure that we have a way of keeping track of
+    # the number of threads being created and preventing utilization of
+    # more than the specified number
+    # Additionally, this class will contain a mutex used to prevent access
+    # to shared variables within sub-threads
+    class ExampleGroupThreadRunner
+      attr_accessor :thread_array, :max_threads, :mutex, :used_threads
+
+      # Creates a new instance of ExampleGroupThreadRunner.
+      # @param max_threads [Integer] the maximum limit of threads that can be used
+      # @param mutex [Mutex] a semaphore used to prevent access to shared variables in
+      # sub-threads such as those used by [ExampleThreadRunner]
+      # @param used_threads [Integer] the current number of threads being used
+      def initialize(max_threads = 1, mutex = Mutex.new, used_threads = 0)
+        @max_threads = max_threads
+        @mutex = mutex
+        @used_threads = used_threads
+        @thread_array = []
+      end
+
+      # Method will run an [ExampleGroup] inside a [Thread] to prevent blocking
+      # execution.  The new [Thread] is added to an array for tracking and
+      # will automatically remove itself when done
+      # @param example_group [ExampleGroup] the group to be run inside a [Thread]
+      # @param reporter [Reporter] the passed in reporting class used for 
+      # tracking
+      def run(example_group, reporter)
+        @thread_array.push Thread.start {
+          example_group.run_parallel(reporter, @max_threads, @mutex, @used_threads)
+          @thread_array.delete Thread.current
+        }
+      end
+
+      # Method will wait for all threads to complete.  On completion threads
+      # remove themselves from the @thread_array so an empty array means they
+      # completed
+      def wait_for_completion
+        @thread_array.each do |t|
+          t.join
+        end
+      end
+    end
+  end
+end

data/lib/rspec/parallel/example_thread_runner.rb

@@ -1,55 +1,55 @@
-module RSpec
-  module Parallel
-    # ExampleThreadRunner is a class used to execute [Example] classes in
-    # parallel as part of rspec-core.  When running in parallel the order
-    # of examples will not be honoured.  
-    # This class is used to ensure that we have a way of keeping track of
-    # the number of threads being created and preventing utilization of
-    # more than the specified number
-    class ExampleThreadRunner
-      attr_accessor :num_threads, :thread_array, :used_threads
-
-      # Creates a new instance of ExampleThreadRunner.
-      # @param num_threads [Integer] the maximum limit of threads that can be used
-      # @param used_threads [Integer] the current number of threads being used
-      def initialize(num_threads, used_threads)
-        @num_threads = num_threads
-        @thread_array = []
-        @used_threads = used_threads
-      end
-
-      # Method will check global utilization of threads and if that number is
-      # at or over the allocated maximum it will wait until a thread is available
-      def wait_for_available_thread
-        while @used_threads.to_i >= @num_threads.to_i
-          sleep 0.1
-        end
-      end
-
-      # Method will run the specified example within an available thread or
-      # will wait for a thread to become available if none currently are
-      # @param example [Example] the example to be executed in a [Thread]
-      # @param instance the instance of an ExampleGroup subclass
-      # @param reporter [Reporter] the passed in reporting class used for 
-      # tracking
-      def run(example, instance, reporter)
-        wait_for_available_thread
-        @thread_array.push Thread.start { 
-          example.run(instance, reporter)
-          @thread_array.delete Thread.current # remove from local scope
-          @used_threads -= 1
-        }
-        @used_threads += 1
-      end
-
-      # Method will wait for all threads to complete.  On completion threads
-      # remove themselves from the @thread_array so an empty array means they
-      # completed
-      def wait_for_completion
-        @thread_array.each do |t|
-          t.join
-        end
-      end
-    end
-  end
-end
+module RSpec
+  module Parallel
+    # ExampleThreadRunner is a class used to execute [Example] classes in
+    # parallel as part of rspec-core.  When running in parallel the order
+    # of examples will not be honoured.  
+    # This class is used to ensure that we have a way of keeping track of
+    # the number of threads being created and preventing utilization of
+    # more than the specified number
+    class ExampleThreadRunner
+      attr_accessor :num_threads, :thread_array, :used_threads
+
+      # Creates a new instance of ExampleThreadRunner.
+      # @param num_threads [Integer] the maximum limit of threads that can be used
+      # @param used_threads [Integer] the current number of threads being used
+      def initialize(num_threads, used_threads)
+        @num_threads = num_threads
+        @thread_array = []
+        @used_threads = used_threads
+      end
+
+      # Method will check global utilization of threads and if that number is
+      # at or over the allocated maximum it will wait until a thread is available
+      def wait_for_available_thread
+        while @used_threads.to_i >= @num_threads.to_i
+          sleep 0.1
+        end
+      end
+
+      # Method will run the specified example within an available thread or
+      # will wait for a thread to become available if none currently are
+      # @param example [Example] the example to be executed in a [Thread]
+      # @param instance the instance of an ExampleGroup subclass
+      # @param reporter [Reporter] the passed in reporting class used for 
+      # tracking
+      def run(example, instance, reporter)
+        wait_for_available_thread
+        @thread_array.push Thread.start { 
+          example.run(instance, reporter)
+          @thread_array.delete Thread.current # remove from local scope
+          @used_threads -= 1
+        }
+        @used_threads += 1
+      end
+
+      # Method will wait for all threads to complete.  On completion threads
+      # remove themselves from the @thread_array so an empty array means they
+      # completed
+      def wait_for_completion
+        @thread_array.each do |t|
+          t.join
+        end
+      end
+    end
+  end
+end

data/lib/rspec/parallel/runner.rb

@@ -23,21 +23,21 @@ module RSpec
         options.parse_options
 
         parallel = (options.options[:thread_maximum].nil?) ? false : true
+        drb = options.options[:drb]
 
-        if options.options[:drb]
+        if drb
           require 'rspec/core/drb_command_line'
           begin
             DRbCommandLine.new(options).run(err, out)
           rescue DRb::DRbConnError
             err.puts "No DRb server is running. Running in local process instead ..."
-            if parallel
-              CommandLine.new(options).run_parallel(err, out)
-            else
-              CommandLine.new(options).run(err, out)
-            end
+            drb = false
           end
-        else
+        end
+
+        unless drb
           if parallel
+            require 'thread'
             CommandLine.new(options).run_parallel(err, out)
           else
             CommandLine.new(options).run(err, out)

data/lib/rspec/parallel/version.rb

@@ -3,7 +3,7 @@ module RSpec
     # Version information for RSpec Parallel.
     module Version
       # Current version of RSpec Parallel, in semantic versioning format.
-      STRING = '2.14.8.1'
+      STRING = '2.14.8.2'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-parallel
 version: !ruby/object:Gem::Version
-  version: 2.14.8.1
+  version: 2.14.8.2
   prerelease: 
 platform: ruby
 authors: