opal-connect-rspec 0.5.0

data/rspec-core/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,126 @@
+require 'rspec/core'  # to fix annoying "undefined method `configuration' for RSpec:Module (NoMethodError)"
+
+Then /^the output should contain all of these:$/ do |table|
+  table.raw.flatten.each do |string|
+    assert_partial_output(string, all_output)
+  end
+end
+
+Then /^the output should not contain any of these:$/ do |table|
+  table.raw.flatten.each do |string|
+    expect(all_output).not_to match(regexp(string))
+  end
+end
+
+Then /^the output should contain one of the following:$/ do |table|
+  matching_output = table.raw.flatten.select do |string|
+    all_output =~ regexp(string)
+  end
+
+  expect(matching_output.count).to eq(1)
+end
+
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  step %q{the output should contain "0 failures"}
+  step %q{the output should not contain "0 examples"}
+  step %q{the exit status should be 0}
+end
+
+Then /^the example(?:s)? should(?: all)? fail$/ do
+  step %q{the output should not contain "0 examples"}
+  step %q{the output should not contain "0 failures"}
+  step %q{the exit status should be 1}
+  example_summary = /(\d+) examples?, (\d+) failures?/.match(all_output)
+  example_count, failure_count = example_summary.captures
+  expect(failure_count).to eq(example_count)
+end
+
+Then /^the process should succeed even though no examples were run$/ do
+  step %q{the output should contain "0 examples, 0 failures"}
+  step %q{the exit status should be 0}
+end
+
+addition_example_formatter_output = <<-EOS
+Addition
+  works
+EOS
+
+Then /^the output from `([^`]+)` (should(?: not)?) be in documentation format$/ do |cmd, should_or_not|
+  step %Q{I run `#{cmd}`}
+  step %q{the examples should all pass}
+  step %Q{the output from "#{cmd}" #{should_or_not} contain "#{addition_example_formatter_output}"}
+end
+
+Then(/^the output from `([^`]+)` should indicate it ran only the subtraction file$/) do |cmd|
+  step %Q{I run `#{cmd}`}
+  step %q{the examples should all pass}
+  step %Q{the output from "#{cmd}" should contain "1 example, 0 failures"}
+  step %Q{the output from "#{cmd}" should contain "Subtraction"}
+  step %Q{the output from "#{cmd}" should not contain "Addition"}
+end
+
+Then /^the backtrace\-normalized output should contain:$/ do |partial_output|
+  # ruby 1.9 includes additional stuff in the backtrace,
+  # so we need to normalize it to compare it with our expected output.
+  normalized_output = all_output.split("\n").map do |line|
+    line =~ /(^\s+# [^:]+:\d+)/ ? $1 : line # http://rubular.com/r/zDD7DdWyzF
+  end.join("\n")
+
+  expect(normalized_output).to match(regexp(partial_output))
+end
+
+Then /^the output should not contain any error backtraces$/ do
+  step %q{the output should not contain "lib/rspec/core"}
+end
+
+# This step can be generalized if it's ever used to test other colors
+Then /^the failing example is printed in magenta$/ do
+  # \e[35m = enable magenta
+  # \e[0m  = reset colors
+  expect(all_output).to include("\e[35m" + "F" + "\e[0m")
+end
+
+Then /^the output from `([^`]+)` should contain "(.*?)"$/  do |cmd, expected_output|
+  step %Q{I run `#{cmd}`}
+  step %Q{the output from "#{cmd}" should contain "#{expected_output}"}
+end
+
+Then /^the output from `([^`]+)` should not contain "(.*?)"$/  do |cmd, expected_output|
+  step %Q{I run `#{cmd}`}
+  step %Q{the output from "#{cmd}" should not contain "#{expected_output}"}
+end
+
+Given /^I have a brand new project with no files$/ do
+  in_current_dir do
+    expect(Dir["**/*"]).to eq([])
+  end
+end
+
+Given /^I have run `([^`]*)`$/ do |cmd|
+  fail_on_error = true
+  run_simple(unescape(cmd), fail_on_error)
+end
+
+Given(/^a vendored gem named "(.*?)" containing a file named "(.*?)" with:$/) do |gem_name, file_name, file_contents|
+  gem_dir = "vendor/#{gem_name}-1.2.3"
+  step %Q{a file named "#{gem_dir}/#{file_name}" with:}, file_contents
+  set_env('RUBYOPT', ENV['RUBYOPT'] + " -I#{gem_dir}/lib")
+end
+
+When "I accept the recommended settings by removing `=begin` and `=end` from `spec/spec_helper.rb`" do
+  in_current_dir do
+    spec_helper = File.read("spec/spec_helper.rb")
+    expect(spec_helper).to include("=begin", "=end")
+
+    to_keep = spec_helper.lines.reject do |line|
+      line.start_with?("=begin") || line.start_with?("=end")
+    end
+
+    File.open("spec/spec_helper.rb", "w") { |f| f.write(to_keep.join) }
+    expect(File.read("spec/spec_helper.rb")).not_to include("=begin", "=end")
+  end
+end
+
+When /^I create "([^"]*)" with the following content:$/ do |file_name, content|
+  write_file(file_name, content)
+end

data/rspec-core/features/step_definitions/core_standalone_steps.rb

@@ -0,0 +1,12 @@
+Given(/^only rspec-core is installed$/) do
+  if RUBY_VERSION.to_f >= 1.9 # --disable-gems is invalid on 1.8.7
+    # Ensure the gem versions of rspec-mocks and rspec-expectations
+    # won't be loaded if available on the developers machine.
+    set_env('RUBYOPT', ENV['RUBYOPT'] + ' --disable-gems')
+  end
+
+  # This will make `require_expect_syntax_in_aruba_specs.rb` (loaded
+  # automatically when the specs run) remove rspec-mocks and
+  # rspec-expectations from the load path.
+  set_env('REMOVE_OTHER_RSPEC_LIBS_FROM_LOAD_PATH', 'true')
+end

data/rspec-core/features/support/env.rb

@@ -0,0 +1,21 @@
+require 'aruba/cucumber'
+
+Before do
+  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
+    @aruba_timeout_seconds = 60
+  else
+    @aruba_timeout_seconds = 10
+  end
+end
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+  end
+end if RUBY_PLATFORM == 'java'
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  end
+end if defined?(Rubinius)

data/rspec-core/features/support/require_expect_syntax_in_aruba_specs.rb

@@ -0,0 +1,29 @@
+if defined?(Cucumber)
+  require 'shellwords'
+  Before('~@allow-should-syntax') do
+    set_env('SPEC_OPTS', "-r#{Shellwords.escape(__FILE__)}")
+  end
+
+  Before('@oneliner-should') do
+    set_env('ALLOW_ONELINER_SHOULD', 'true')
+  end
+else
+  if ENV['REMOVE_OTHER_RSPEC_LIBS_FROM_LOAD_PATH']
+    $LOAD_PATH.reject! { |x| /rspec-mocks/ === x || /rspec-expectations/ === x }
+  end
+
+  module DisallowOneLinerShould
+    def should(*)
+      raise "one-liner should is not allowed"
+    end
+
+    def should_not(*)
+      raise "one-liner should_not is not allowed"
+    end
+  end
+
+  RSpec.configure do |rspec|
+    rspec.disable_monkey_patching!
+    rspec.include DisallowOneLinerShould unless ENV['ALLOW_ONELINER_SHOULD']
+  end
+end

data/rspec-core/features/support/rubinius.rb

@@ -0,0 +1,6 @@
+# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
+ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
+
+Around "@unsupported-on-rbx" do |scenario, block|
+  block.call unless defined?(Rubinius)
+end

data/rspec-core/lib/rspec/autorun.rb

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

data/rspec-core/lib/rspec/core.rb

@@ -0,0 +1,169 @@
+# rubocop:disable Style/GlobalVars
+$_rspec_core_load_started_at = Time.now
+# rubocop:enable Style/GlobalVars
+
+require 'rbconfig'
+
+require "rspec/support"
+RSpec::Support.require_rspec_support "caller_filter"
+
+RSpec::Support.define_optimized_require_for_rspec(:core) { |f| require_relative f }
+
+%w[
+  version
+  warnings
+
+  flat_map
+  filter_manager
+  dsl
+  notifications
+  reporter
+
+  hooks
+  memoized_helpers
+  metadata
+  metadata_filter
+  pending
+  formatters
+  ordering
+
+  world
+  configuration
+  option_parser
+  configuration_options
+  runner
+  example
+  shared_example_group
+  example_group
+].each { |name| RSpec::Support.require_rspec_core name }
+
+# Namespace for all core RSpec code.
+module RSpec
+  autoload :SharedContext, 'rspec/core/shared_context'
+
+  extend RSpec::Core::Warnings
+
+  # Used to ensure examples get reloaded between multiple runs in
+  # the same process.
+  #
+  # Users must invoke this if they want to have the configuration reset when
+  # they use runner multiple times within the same process.
+  def self.reset
+    @world = nil
+    @configuration = nil
+  end
+
+  # Returns the global [Configuration](RSpec/Core/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 Core::Configuration
+  def self.configuration
+    @configuration ||= begin
+                         config = RSpec::Core::Configuration.new
+                         config.expose_dsl_globally = true
+                         config
+                       end
+  end
+
+  # Yields the global configuration to a block.
+  # @yield [Configuration] global configuration
+  #
+  # @example
+  #     RSpec.configure do |config|
+  #       config.add_formatter 'documentation'
+  #     end
+  # @see Core::Configuration
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  # The example being executed.
+  #
+  # The primary audience for this method is library authors who need access
+  # to the example currently being executed and also want to support all
+  # versions of RSpec 2 and 3.
+  #
+  # @example
+  #
+  #     RSpec.configure do |c|
+  #       # context.example is deprecated, but RSpec.current_example is not
+  #       # available until RSpec 3.0.
+  #       fetch_current_example = RSpec.respond_to?(:current_example) ?
+  #         proc { RSpec.current_example } : proc { |context| context.example }
+  #
+  #       c.before(:example) do
+  #         example = fetch_current_example.call(self)
+  #
+  #         # ...
+  #       end
+  #     end
+  #
+  def self.current_example
+    thread_local_metadata[:current_example]
+  end
+
+  # Set the current example being executed.
+  # @api private
+  def self.current_example=(example)
+    thread_local_metadata[:current_example] = example
+  end
+
+  # @private
+  # A single thread local variable so we don't excessively pollute that
+  # namespace.
+  def self.thread_local_metadata
+    Thread.current[:_rspec] ||= {}
+  end
+
+  # @private
+  # Internal container for global non-configuration data
+  def self.world
+    @world ||= RSpec::Core::World.new
+  end
+
+  # Namespace for the rspec-core code.
+  module Core
+    # @private
+    # This avoids issues with reporting time caused by examples that
+    # change the value/meaning of Time.now without properly restoring
+    # it.
+    class Time
+      class << self
+        define_method(:now, &::Time.method(:now))
+      end
+    end
+
+    # @private path to executable file
+    def self.path_to_executable
+      @path_to_executable ||= File.expand_path('../../../exe/rspec', __FILE__)
+    end
+  end
+
+  # @private
+  MODULES_TO_AUTOLOAD = {
+    :Matchers     => "rspec/expectations",
+    :Expectations => "rspec/expectations",
+    :Mocks        => "rspec/mocks"
+  }
+
+  # @private
+  def self.const_missing(name)
+    # Load rspec-expectations when RSpec::Matchers is referenced. This allows
+    # people to define custom matchers (using `RSpec::Matchers.define`) before
+    # rspec-core has loaded rspec-expectations (since it delays the loading of
+    # it to allow users to configure a different assertion/expectation
+    # framework). `autoload` can't be used since it works with ruby's built-in
+    # require (e.g. for files that are available relative to a load path dir),
+    # but not with rubygems' extended require.
+    #
+    # As of rspec 2.14.1, we no longer require `rspec/mocks` and
+    # `rspec/expectations` when `rspec` is required, so we want
+    # to make them available as an autoload.
+    require MODULES_TO_AUTOLOAD.fetch(name) { return super }
+    ::RSpec.const_get(name)
+  end
+end

data/rspec-core/lib/rspec/core/backport_random.rb

@@ -0,0 +1,336 @@
+module RSpec
+  module Core
+    # @private
+    #
+    # Methods used internally by the backports.
+    #
+    # This code was (mostly) ported from the backports gem found at
+    # https://github.com/marcandre/backports which is subject to this license:
+    #
+    # =========================================================================
+    #
+    # Copyright (c) 2009 Marc-Andre Lafortune
+    #
+    # Permission is hereby granted, free of charge, to any person obtaining
+    # a copy of this software and associated documentation files (the
+    # "Software"), to deal in the Software without restriction, including
+    # without limitation the rights to use, copy, modify, merge, publish,
+    # distribute, sublicense, and/or sell copies of the Software, and to
+    # permit persons to whom the Software is furnished to do so, subject to
+    # the following conditions:
+    #
+    # The above copyright notice and this permission notice shall be
+    # included in all copies or substantial portions of the Software.
+    #
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    #
+    # =========================================================================
+    #
+    # The goal is to provide a random number generator in Ruby versions that do
+    # not have one. This was added to support localization of random spec
+    # ordering.
+    #
+    # These were in multiple files in backports, but merged into one here.
+    module Backports
+      # Helper method to coerce a value into a specific class.
+      # Raises a TypeError if the coercion fails or the returned value
+      # is not of the right class.
+      # (from Rubinius)
+      def self.coerce_to(obj, cls, meth)
+        return obj if obj.kind_of?(cls)
+
+        begin
+          ret = obj.__send__(meth)
+        rescue Exception => e
+          raise TypeError, "Coercion error: #{obj.inspect}.#{meth} => #{cls} failed:\n" \
+                           "(#{e.message})"
+        end
+        raise TypeError, "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{ret.class})" unless ret.kind_of? cls
+        ret
+      end
+
+      # @private
+      def self.coerce_to_int(obj)
+        coerce_to(obj, Integer, :to_int)
+      end
+
+      # Used internally to make it easy to deal with optional arguments
+      # (from Rubinius)
+      Undefined = Object.new
+
+      # @private
+      class Random
+        # @private
+        # An implementation of Mersenne Twister MT19937 in Ruby
+        class MT19937
+          STATE_SIZE = 624
+          LAST_STATE = STATE_SIZE - 1
+          PAD_32_BITS = 0xffffffff
+
+          # See seed=
+          def initialize(seed)
+            self.seed = seed
+          end
+
+          LAST_31_BITS = 0x7fffffff
+          OFFSET = 397
+
+          # Generates a completely new state out of the previous one.
+          def next_state
+            STATE_SIZE.times do |i|
+              mix = @state[i] & 0x80000000 | @state[i+1 - STATE_SIZE] & 0x7fffffff
+              @state[i] = @state[i+OFFSET - STATE_SIZE] ^ (mix >> 1)
+              @state[i] ^= 0x9908b0df if mix.odd?
+            end
+            @last_read = -1
+          end
+
+          # Seed must be either an Integer (only the first 32 bits will be used)
+          # or an Array of Integers (of which only the first 32 bits will be used)
+          #
+          # No conversion or type checking is done at this level
+          def seed=(seed)
+            case seed
+            when Integer
+              @state = Array.new(STATE_SIZE)
+              @state[0] = seed & PAD_32_BITS
+              (1..LAST_STATE).each do |i|
+                @state[i] = (1812433253 * (@state[i-1]  ^ @state[i-1]>>30) + i)& PAD_32_BITS
+              end
+              @last_read = LAST_STATE
+            when Array
+              self.seed = 19650218
+              i=1
+              j=0
+              [STATE_SIZE, seed.size].max.times do
+                @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1664525) + j + seed[j] & PAD_32_BITS
+                if (i+=1) >= STATE_SIZE
+                  @state[0] = @state[-1]
+                  i = 1
+                end
+                j = 0 if (j+=1) >= seed.size
+              end
+              (STATE_SIZE-1).times do
+                @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1566083941) - i & PAD_32_BITS
+                if (i+=1) >= STATE_SIZE
+                  @state[0] = @state[-1]
+                  i = 1
+                end
+              end
+              @state[0] = 0x80000000
+            else
+              raise ArgumentError, "Seed must be an Integer or an Array"
+            end
+          end
+
+          # Returns a random Integer from the range 0 ... (1 << 32)
+          def random_32_bits
+            next_state if @last_read >= LAST_STATE
+            @last_read += 1
+            y = @state[@last_read]
+            # Tempering
+            y ^= (y >> 11)
+            y ^= (y << 7) & 0x9d2c5680
+            y ^= (y << 15) & 0xefc60000
+            y ^= (y >> 18)
+          end
+
+          # Supplement the MT19937 class with methods to do
+          # conversions the same way as MRI.
+          # No argument checking is done here either.
+
+          FLOAT_FACTOR = 1.0/9007199254740992.0
+          # generates a random number on [0,1) with 53-bit resolution
+          def random_float
+            ((random_32_bits >> 5) * 67108864.0 + (random_32_bits >> 6)) * FLOAT_FACTOR;
+          end
+
+          # Returns an integer within 0...upto
+          def random_integer(upto)
+            n = upto - 1
+            nb_full_32 = 0
+            while n > PAD_32_BITS
+              n >>= 32
+              nb_full_32 += 1
+            end
+            mask = mask_32_bits(n)
+            begin
+              rand = random_32_bits & mask
+              nb_full_32.times do
+                rand <<= 32
+                rand |= random_32_bits
+              end
+            end until rand < upto
+            rand
+          end
+
+          def random_bytes(nb)
+            nb_32_bits = (nb + 3) / 4
+            random = nb_32_bits.times.map { random_32_bits }
+            random.pack("L" * nb_32_bits)[0, nb]
+          end
+
+          def state_as_bignum
+            b = 0
+            @state.each_with_index do |val, i|
+              b |= val << (32 * i)
+            end
+            b
+          end
+
+          def left # It's actually the number of words left + 1, as per MRI...
+            MT19937::STATE_SIZE - @last_read
+          end
+
+          def marshal_dump
+            [state_as_bignum, left]
+          end
+
+          def marshal_load(ary)
+            b, left = ary
+            @last_read = MT19937::STATE_SIZE - left
+            @state = Array.new(STATE_SIZE)
+            STATE_SIZE.times do |i|
+              @state[i] = b & PAD_32_BITS
+              b >>= 32
+            end
+          end
+
+          # Convert an Integer seed of arbitrary size to either a single 32 bit integer, or an Array of 32 bit integers
+          def self.convert_seed(seed)
+            seed = seed.abs
+            long_values = []
+            begin
+              long_values << (seed & PAD_32_BITS)
+              seed >>= 32
+            end until seed == 0
+
+            long_values.pop if long_values[-1] == 1 && long_values.size > 1 # Done to allow any kind of sequence of integers
+
+            long_values.size > 1 ? long_values : long_values.first
+          end
+
+          def self.[](seed)
+            new(convert_seed(seed))
+          end
+
+          private
+
+          MASK_BY = [1,2,4,8,16]
+          def mask_32_bits(n)
+            MASK_BY.each do |shift|
+              n |= n >> shift
+            end
+            n
+          end
+        end
+
+        # @private
+        # Implementation corresponding to the actual Random class of Ruby
+        # The actual random generator (mersenne twister) is in MT19937.
+        # Ruby specific conversions are handled in bits_and_bytes.
+        # The high level stuff (argument checking) is done here.
+        module Implementation
+          attr_reader :seed
+
+          def initialize(seed = 0)
+            super()
+            seed_rand seed
+          end
+
+          def seed_rand(new_seed = 0)
+            new_seed = Backports.coerce_to_int(new_seed)
+            @seed = nil unless defined?(@seed)
+            old, @seed = @seed, new_seed.nonzero? || Random.new_seed
+            @mt = MT19937[ @seed ]
+            old
+          end
+
+          def rand(limit = Backports::Undefined)
+            case limit
+              when Backports::Undefined
+                @mt.random_float
+              when Float
+                limit * @mt.random_float unless limit <= 0
+              when Range
+                _rand_range(limit)
+              else
+                limit = Backports.coerce_to_int(limit)
+                @mt.random_integer(limit) unless limit <= 0
+            end || raise(ArgumentError, "invalid argument #{limit}")
+          end
+
+          def bytes(nb)
+            nb = Backports.coerce_to_int(nb)
+            raise ArgumentError, "negative size" if nb < 0
+            @mt.random_bytes(nb)
+          end
+
+          def ==(other)
+            other.is_a?(Random) &&
+              seed == other.seed &&
+              left == other.send(:left) &&
+              state == other.send(:state)
+          end
+
+          def marshal_dump
+            @mt.marshal_dump << @seed
+          end
+
+          def marshal_load(ary)
+            @seed = ary.pop
+            @mt = MT19937.allocate
+            @mt.marshal_load(ary)
+          end
+
+          private
+
+          def state
+            @mt.state_as_bignum
+          end
+
+          def left
+            @mt.left
+          end
+
+          def _rand_range(limit)
+            range = limit.end - limit.begin
+            if (!range.is_a?(Float)) && range.respond_to?(:to_int) && range = Backports.coerce_to_int(range)
+              range += 1 unless limit.exclude_end?
+              limit.begin + @mt.random_integer(range) unless range <= 0
+            elsif range = Backports.coerce_to(range, Float, :to_f)
+              if range < 0
+                nil
+              elsif limit.exclude_end?
+                limit.begin + @mt.random_float * range unless range <= 0
+              else
+                # cheat a bit... this will reduce the nb of random bits
+                loop do
+                  r = @mt.random_float * range * 1.0001
+                  break limit.begin + r unless r > range
+                end
+              end
+            end
+          end
+        end
+
+        def self.new_seed
+          (2 ** 62) + Kernel.rand(2 ** 62)
+        end
+      end
+
+      class Random
+        include Implementation
+        class << self
+          include Implementation
+        end
+      end
+    end
+  end
+end