rspec-parallel 2.14.8.1

data/bin/rspec

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rspec/autorun'
+rescue LoadError
+  $stderr.puts <<-EOS
+#{'*'*50}
+Could not find 'rspec/autorun'
+
+This may happen if you're using rubygems as your package manager, but it is not
+being required through some mechanism before executing the rspec command.
+
+You may need to do one of the following in your shell:
+
+# for bash/zsh
+export RUBYOPT=rubygems
+
+# for csh, etc.
+set RUBYOPT=rubygems
+
+For background, please see http://gist.github.com/54177.
+#{'*'*50}
+EOS
+  exit(1)
+end

data/lib/rspec/parallel/autorun.rb

@@ -0,0 +1,2 @@
+require 'rspec/core'
+RSpec::Parallel::Runner.autorun

data/lib/rspec/parallel/command_line.rb

@@ -0,0 +1,44 @@
+module RSpec
+  module Parallel
+    class CommandLine < RSpec::Core::CommandLine
+      def initialize(options, configuration=RSpec::configuration, world=RSpec::world)
+        if Array === options
+          options = ConfigurationOptions.new(options)
+          options.parse_options
+        end
+        @options = options
+        @configuration = configuration
+        @world = world
+      end
+
+      # Configures and runs a suite
+      #
+      # @param [IO] err
+      # @param [IO] out
+      def run_parallel(err, out)
+        @configuration.error_stream = err
+        @configuration.output_stream ||= out
+        @options.configure(@configuration)
+        @configuration.load_spec_files
+        @world.announce_filters
+
+        @configuration.reporter.report(@world.example_count, @configuration.randomize? ? @configuration.seed : nil) do |reporter|
+          begin
+            @configuration.run_hook(:before, :suite)
+            group_threads = RSpec::Parallel::ExampleGroupThreadRunner.new(@configuration.thread_maximum)
+            @world.example_groups.ordered.map {|g| group_threads.run(g, reporter)}
+            group_threads.wait_for_completion
+
+            @world.example_groups.all? do |g| 
+              result_for_this_group = g.filtered_examples.all? { |example| example.metadata[:execution_result].exception.nil? }
+              results_for_descendants = g.children.all? { |child| child.filtered_examples.all? { |example| example.metadata[:execution_result].exception.nil? } }
+              result_for_this_group && results_for_descendants
+            end ? 0 : @configuration.failure_exit_code
+          ensure
+            @configuration.run_hook(:after, :suite)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/parallel/configuration.rb

@@ -0,0 +1,12 @@
+module RSpec
+  module Parallel
+    class Configuration < RSpec::Core::Configuration
+      attr_accessor :thread_maximum
+
+      def initialize
+        super
+        @thread_maximum = 1
+      end
+    end
+  end
+end

data/lib/rspec/parallel/configuration_options.rb

@@ -0,0 +1,10 @@
+module RSpec
+  module Parallel
+    class ConfigurationOptions < RSpec::Core::ConfigurationOptions
+      UNFORCED_OPTIONS = [
+        :requires, :profile, :drb, :libs, :files_or_directories_to_run,
+        :full_description, :full_backtrace, :tty, :thread_maximum
+      ].to_set
+    end
+  end
+end

data/lib/rspec/parallel/example_group_thread_runner.rb

@@ -0,0 +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

data/lib/rspec/parallel/example_thread_runner.rb

@@ -0,0 +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

data/lib/rspec/parallel/option_parser.rb

@@ -0,0 +1,213 @@
+module RSpec
+  module Parallel
+    class Parser < RSpec::Core::Parser
+      def parser(options)
+      OptionParser.new do |parser|
+        parser.banner = "Usage: rspec [options] [files or directories]\n\n"
+
+        parser.on('-I PATH', 'Specify PATH to add to $LOAD_PATH (may be used more than once).') do |dir|
+          options[:libs] ||= []
+          options[:libs] << dir
+        end
+
+        parser.on('-r', '--require PATH', 'Require a file.') do |path|
+          options[:requires] ||= []
+          options[:requires] << path
+        end
+
+        parser.on('-O', '--options PATH', 'Specify the path to a custom options file.') do |path|
+          options[:custom_options_file] = path
+        end
+
+        parser.on('--order TYPE[:SEED]', 'Run examples by the specified order type.',
+                  '  [defined] examples and groups are run in the order they are defined',
+                  '  [rand]    randomize the order of groups and examples',
+                  '  [random]  alias for rand',
+                  '  [random:SEED] e.g. --order random:123') do |o|
+          options[:order] = o
+        end
+
+        parser.on('--seed SEED', Integer, 'Equivalent of --order rand:SEED.') do |seed|
+          options[:order] = "rand:#{seed}"
+        end
+
+        parser.on('--fail-fast', 'Abort the run on first failure.') do |o|
+          options[:fail_fast] = true
+        end
+
+        parser.on('--no-fail-fast', 'Do not abort the run on first failure.') do |o|
+          options[:fail_fast] = false
+        end
+
+        parser.on('--failure-exit-code CODE', Integer, 'Override the exit code used when there are failing specs.') do |code|
+          options[:failure_exit_code] = code
+        end
+
+        parser.on('--dry-run', 'Print the formatter output of your suite without',
+                  '  running any examples or hooks') do |o|
+          options[:dry_run] = true
+        end
+
+        parser.on('-X', '--[no-]drb', 'Run examples via DRb.') do |o|
+          options[:drb] = o
+        end
+
+        parser.on('--drb-port PORT', 'Port to connect to the DRb server.') do |o|
+          options[:drb_port] = o.to_i
+        end
+
+        parser.on('--init', 'Initialize your project with RSpec.') do |cmd|
+          RSpec::Support.require_rspec_core "project_initializer"
+          ProjectInitializer.new.run
+          exit
+        end
+
+        parser.separator("\n  **** Output ****\n\n")
+
+        parser.on('-f', '--format FORMATTER', 'Choose a formatter.',
+                '  [p]rogress (default - dots)',
+                '  [d]ocumentation (group and example names)',
+                '  [h]tml',
+                '  [j]son',
+                '  custom formatter class name') do |o|
+          options[:formatters] ||= []
+          options[:formatters] << [o]
+        end
+
+        parser.on('-o', '--out FILE',
+                  'Write output to a file instead of $stdout. This option applies',
+                  '  to the previously specified --format, or the default format',
+                  '  if no format is specified.'
+                 ) do |o|
+          options[:formatters] ||= [['progress']]
+          options[:formatters].last << o
+        end
+
+        parser.on('--deprecation-out FILE', 'Write deprecation warnings to a file instead of $stderr.') do |file|
+          options[:deprecation_stream] = file
+        end
+
+        parser.on('-b', '--backtrace', 'Enable full backtrace.') do |o|
+          options[:full_backtrace] = true
+        end
+
+        parser.on('-c', '--[no-]color', '--[no-]colour', 'Enable color in the output.') do |o|
+          options[:color] = o
+        end
+
+        parser.on('-p', '--[no-]profile [COUNT]', 'Enable profiling of examples and list the slowest examples (default: 10).') do |argument|
+          options[:profile_examples] = if argument.nil?
+                                         true
+                                       elsif argument == false
+                                         false
+                                       else
+                                         begin
+                                           Integer(argument)
+                                         rescue ArgumentError
+                                           RSpec.warning "Non integer specified as profile count, seperate " +
+                                                       "your path from options with -- e.g. " +
+                                                       "`rspec --profile -- #{argument}`",
+                                                       :call_site => nil
+                                           true
+                                         end
+                                       end
+        end
+
+        parser.on('-w', '--warnings', 'Enable ruby warnings') do
+          $VERBOSE = true
+        end
+
+        parser.on('--parallel-test NUMBER', 'Run the tests with the specified number of parallel threads (default: 1).') do |n|
+          options[:thread_maximum] = if !n.nil?
+                                      begin
+                                        Integer(n)
+                                      rescue ArgumentError
+                                        RSpec.warning "Non integer specified as number of parallel threads, seperate " +
+                                                       "your path from options with a space e.g. " +
+                                                       "`rspec --parallel-test #{n}`",
+                                                       :call_site => nil
+                                        1
+                                      end
+                                    end
+        end
+
+        parser.separator <<-FILTERING
+
+  **** Filtering/tags ****
+
+    In addition to the following options for selecting specific files, groups,
+    or examples, you can select a single example by appending the line number to
+    the filename:
+
+      rspec path/to/a_spec.rb:37
+
+FILTERING
+
+        parser.on('-P', '--pattern PATTERN', 'Load files matching pattern (default: "spec/**/*_spec.rb").') do |o|
+          options[:pattern] = o
+        end
+
+        parser.on('-e', '--example STRING', "Run examples whose full nested names include STRING (may be",
+                                            "  used more than once)") do |o|
+          (options[:full_description] ||= []) << Regexp.compile(Regexp.escape(o))
+        end
+
+        parser.on('-t', '--tag TAG[:VALUE]',
+                  'Run examples with the specified tag, or exclude examples',
+                  'by adding ~ before the tag.',
+                  '  - e.g. ~slow',
+                  '  - TAG is always converted to a symbol') do |tag|
+          filter_type = tag =~ /^~/ ? :exclusion_filter : :inclusion_filter
+
+          name,value = tag.gsub(/^(~@|~|@)/, '').split(':',2)
+          name = name.to_sym
+
+          options[filter_type] ||= {}
+          options[filter_type][name] = case value
+                                         when  nil        then true # The default value for tags is true
+                                         when 'true'      then true
+                                         when 'false'     then false
+                                         when 'nil'       then nil
+                                         when /^:/        then value[1..-1].to_sym
+                                         when /^\d+$/     then Integer(value)
+                                         when /^\d+.\d+$/ then Float(value)
+                                       else
+                                         value
+                                       end
+        end
+
+        parser.on('--default-path PATH', 'Set the default path where RSpec looks for examples (can',
+                                         '  be a path to a file or a directory).') do |path|
+          options[:default_path] = path
+        end
+
+        parser.separator("\n  **** Utility ****\n\n")
+
+        parser.on('-v', '--version', 'Display the version.') do
+          puts RSpec::Core::Version::STRING
+          exit
+        end
+
+        # these options would otherwise be confusing to users, so we forcibly prevent them from executing
+        # --I is too similar to -I
+        # -d was a shorthand for --debugger, which is removed, but now would trigger --default-path
+        invalid_options = %w[-d --I]
+
+        parser.on_tail('-h', '--help', "You're looking at it.") do
+          # removing the blank invalid options from the output
+          puts parser.to_s.gsub(/^\s+(#{invalid_options.join('|')})\s*$\n/,'')
+          exit
+        end
+
+        # this prevents usage of the invalid_options
+        invalid_options.each do |option|
+          parser.on(option) do
+            raise OptionParser::InvalidOption.new
+          end
+        end
+
+      end
+    end
+    end
+  end
+end

data/lib/rspec/parallel/runner.rb

@@ -0,0 +1,51 @@
+module RSpec
+  module Parallel
+    class Runner < RSpec::Core::Runner
+      # Run a suite of RSpec examples.
+      #
+      # This is used internally by RSpec to run a suite, but is available
+      # for use by any other automation tool.
+      #
+      # If you want to run this multiple times in the same process, and you
+      # want files like spec_helper.rb to be reloaded, be sure to load `load`
+      # instead of `require`.
+      #
+      # #### Parameters
+      # * +args+ - an array of command-line-supported arguments
+      # * +err+ - error stream (Default: $stderr)
+      # * +out+ - output stream (Default: $stdout)
+      #
+      # #### Returns
+      # * +Fixnum+ - exit status code (0/1)
+      def self.run(args, err=$stderr, out=$stdout)
+        trap_interrupt
+        options = ConfigurationOptions.new(args)
+        options.parse_options
+
+        parallel = (options.options[:thread_maximum].nil?) ? false : true
+
+        if options.options[: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
+          end
+        else
+          if parallel
+            CommandLine.new(options).run_parallel(err, out)
+          else
+            CommandLine.new(options).run(err, out)
+          end
+        end
+      ensure
+        RSpec.reset
+      end
+    end
+  end
+end

data/lib/rspec/parallel/version.rb

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

data/lib/rspec/parallel.rb

@@ -0,0 +1,79 @@
+require 'rspec'
+require_rspec = if defined?(require_relative)
+  lambda do |path|
+    require_relative path
+  end
+else
+  lambda do |path|
+    require "rspec/#{path}"
+  end
+end
+
+require_rspec['parallel/version']
+require_rspec['parallel/configuration']
+require_rspec['parallel/option_parser']
+require_rspec['parallel/configuration_options']
+require_rspec['parallel/example_thread_runner']
+require_rspec['parallel/example_group_thread_runner']
+require_rspec['parallel/runner']
+
+module RSpec
+  # Returns the global [Configuration](RSpec/Parallel/Configuration) object. While you
+  # _can_ use this method to access the configuration, the more common
+  # convention is to use [RSpec.configure](RSpec#configure-class_method).
+  #
+  # @example
+  #     RSpec.configuration.drb_port = 1234
+  # @see RSpec.configure
+  # @see Parallel::Configuration
+  def self.configuration
+    @configuration ||= begin
+                         config = RSpec::Parallel::Configuration.new
+                         config.expose_dsl_globally = true
+                         config
+                       end
+
+  end
+
+  module Parallel
+    class << RSpec::Core::ExampleGroup
+      # Runs all the examples in this group in a separate thread for each
+      def run_parallel(reporter, num_threads, mutex, used_threads)
+        if RSpec.wants_to_quit
+          RSpec.clear_remaining_example_groups if top_level?
+          return
+        end
+        reporter.example_group_started(self)
+
+        begin
+          run_before_all_hooks(new)
+          example_threads = RSpec::Parallel::ExampleThreadRunner.new(num_threads, used_threads)
+          run_examples_parallel(reporter, example_threads, mutex)
+          children.ordered.map {|child| child.run_parallel(reporter, num_threads, mutex, used_threads)}
+          example_threads.wait_for_completion
+        rescue Exception => ex
+          RSpec.wants_to_quit = true if fail_fast?
+          fail_filtered_examples(ex, reporter)
+        ensure
+          run_after_all_hooks(new)
+          before_all_ivars.clear
+          reporter.example_group_finished(self)
+        end
+      end
+
+      # @private
+      # Runs the examples in this group in a separate thread each
+      def run_examples_parallel(reporter, threads, mutex)
+        filtered_examples.ordered.map do |example|
+          next if RSpec.wants_to_quit
+          instance = new
+          set_ivars(instance, before_all_ivars)
+          mutex.synchronize do
+            threads.run(example, instance, reporter)
+          end
+          RSpec.wants_to_quit = true if fail_fast?
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: rspec-parallel
+version: !ruby/object:Gem::Version
+  version: 2.14.8.1
+  prerelease: 
+platform: ruby
+authors:
+- Jason Holt Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+description: Bolt-on gem allowing for parallel execution of examples using rspec's
+  framework
+email: bicarbon8@gmail.com
+executables:
+- rspec
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rspec/parallel.rb
+- lib/rspec/parallel/autorun.rb
+- lib/rspec/parallel/command_line.rb
+- lib/rspec/parallel/configuration.rb
+- lib/rspec/parallel/configuration_options.rb
+- lib/rspec/parallel/example_group_thread_runner.rb
+- lib/rspec/parallel/example_thread_runner.rb
+- lib/rspec/parallel/option_parser.rb
+- lib/rspec/parallel/runner.rb
+- lib/rspec/parallel/version.rb
+- bin/rspec
+homepage: https://github.com/bicarbon8/rspec-parallel.git
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Parallel rspec execution gem
+test_files: []
+has_rdoc: