opal-rspec 0.6.2 → 0.7.0.rc.1

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

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

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

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

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

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

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

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

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

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