opal-rspec 0.4.3 → 0.5.0.beta1

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/{vendor_lib → rspec-core/lib}/rspec/core/backport_random.rb

@@ -1,12 +1,42 @@
-# This code was (mostly) ported from the backports gem (https://github.com/marcandre/backports).
-# 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 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
@@ -25,6 +55,7 @@ module RSpec
         ret
       end
 
+      # @private
       def self.coerce_to_int(obj)
         coerce_to(obj, Integer, :to_int)
       end
@@ -33,7 +64,9 @@ module RSpec
       # (from Rubinius)
       Undefined = Object.new
 
+      # @private
       class Random
+        # @private
         # An implementation of Mersenne Twister MT19937 in Ruby
         class MT19937
           STATE_SIZE = 624
@@ -198,6 +231,7 @@ module RSpec
           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.

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

@@ -0,0 +1,66 @@
+module RSpec
+  module Core
+    # @private
+    class BacktraceFormatter
+      # @private
+      attr_accessor :exclusion_patterns, :inclusion_patterns
+
+      def initialize
+        @full_backtrace = false
+
+        patterns = %w[ /lib\d*/ruby/ bin/ exe/rspec ]
+        patterns << "org/jruby/" if RUBY_PLATFORM == 'java'
+        patterns.map! { |s| Regexp.new(s.gsub("/", File::SEPARATOR)) }
+
+        @exclusion_patterns = [Regexp.union(RSpec::CallerFilter::IGNORE_REGEX, *patterns)]
+        @inclusion_patterns = []
+
+        return unless matches?(@exclusion_patterns, File.join(Dir.getwd, "lib", "foo.rb:13"))
+        inclusion_patterns << Regexp.new(Dir.getwd)
+      end
+
+      attr_writer :full_backtrace
+
+      def full_backtrace?
+        @full_backtrace || exclusion_patterns.empty?
+      end
+
+      def filter_gem(gem_name)
+        sep = File::SEPARATOR
+        exclusion_patterns << /#{sep}#{gem_name}(-[^#{sep}]+)?#{sep}/
+      end
+
+      def format_backtrace(backtrace, options={})
+        return backtrace if options[:full_backtrace]
+
+        backtrace.map { |l| backtrace_line(l) }.compact.
+          tap do |filtered|
+            if filtered.empty?
+              filtered.concat backtrace
+              filtered << ""
+              filtered << "  Showing full backtrace because every line was filtered out."
+              filtered << "  See docs for RSpec::Configuration#backtrace_exclusion_patterns and"
+              filtered << "  RSpec::Configuration#backtrace_inclusion_patterns for more information."
+            end
+          end
+      end
+
+      def backtrace_line(line)
+        Metadata.relative_path(line) unless exclude?(line)
+      rescue SecurityError
+        nil
+      end
+
+      def exclude?(line)
+        return false if @full_backtrace
+        matches?(exclusion_patterns, line) && !matches?(inclusion_patterns, line)
+      end
+
+    private
+
+      def matches?(patterns, line)
+        patterns.any? { |p| line =~ p }
+      end
+    end
+  end
+end