opal-rspec 0.7.0.rc.1 → 0.7.0.rc.2

data/rspec-core/upstream/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/upstream/features/subject/explicit_subject.feature

@@ -0,0 +1,187 @@
+Feature: Explicit Subject
+
+  Use `subject` in the group scope to explicitly define the value that is returned by the
+  `subject` method in the example scope.
+
+  Note that while the examples below demonstrate how the `subject` helper can be used
+  as a user-facing concept, we recommend that you reserve it for support of custom
+  matchers and/or extension libraries that hide its use from examples.
+
+  A named `subject` improves on the explicit `subject` by assigning it a contextually
+  semantic name. Since a named `subject` is an explicit `subject`, it still defines the value
+  that is returned by the `subject` method in the example scope. However, it defines an
+  additional helper method with the provided name. This helper method is memoized.
+  The value is cached across multiple calls in the same example but not across examples.
+
+  We recommend using the named helper method over `subject` in examples.
+
+  For more information about declaring a `subject` see the [API docs](http://rubydoc.info/github/rspec/rspec-core/RSpec/Core/MemoizedHelpers/ClassMethods#subject-instance_method).
+
+  Scenario: A `subject` can be defined and used in the top level group scope
+    Given a file named "top_level_subject_spec.rb" with:
+      """ruby
+      RSpec.describe Array, "with some elements" do
+        subject { [1, 2, 3] }
+
+        it "has the prescribed elements" do
+          expect(subject).to eq([1, 2, 3])
+        end
+      end
+      """
+    When I run `rspec top_level_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: The `subject` defined in an outer group is available to inner groups
+    Given a file named "nested_subject_spec.rb" with:
+      """ruby
+      RSpec.describe Array do
+        subject { [1, 2, 3] }
+
+        describe "has some elements" do
+          it "which are the prescribed elements" do
+            expect(subject).to eq([1, 2, 3])
+          end
+        end
+      end
+      """
+    When I run `rspec nested_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: The `subject` is memoized within an example but not across examples
+    **Note:** This scenario shows mutation being performed in a `subject` definition block. This
+    behavior is generally discouraged as it makes it more difficult to understand the specs.
+    This is technique is used simply as a tool to demonstrate how the memoization occurs.
+    Given a file named "memoized_subject_spec.rb" with:
+      """ruby
+      RSpec.describe Array do
+        # This uses a context local variable. As you can see from the
+        # specs, it can mutate across examples. Use with caution.
+        element_list = [1, 2, 3]
+
+        subject { element_list.pop }
+
+        it "is memoized across calls (i.e. the block is invoked once)" do
+          expect {
+            3.times { subject }
+          }.to change{ element_list }.from([1, 2, 3]).to([1, 2])
+          expect(subject).to eq(3)
+        end
+
+        it "is not memoized across examples" do
+          expect{ subject }.to change{ element_list }.from([1, 2]).to([1])
+          expect(subject).to eq(2)
+        end
+      end
+      """
+    When I run `rspec memoized_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: The `subject` is available in `before` hooks
+    Given a file named "before_hook_subject_spec.rb" with:
+      """ruby
+      RSpec.describe Array, "with some elements" do
+        subject { [] }
+
+        before { subject.push(1, 2, 3) }
+
+        it "has the prescribed elements" do
+          expect(subject).to eq([1, 2, 3])
+        end
+      end
+      """
+    When I run `rspec before_hook_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Helper methods can be invoked from a `subject` definition block
+    Given a file named "helper_subject_spec.rb" with:
+      """ruby
+      RSpec.describe Array, "with some elements" do
+        def prepared_array
+          [1, 2, 3]
+        end
+
+        subject { prepared_array }
+
+        it "has the prescribed elements" do
+          expect(subject).to eq([1, 2, 3])
+        end
+      end
+      """
+    When I run `rspec helper_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Use the `subject!` bang method to call the definition block before the example
+    Given a file named "subject_bang_spec.rb" with:
+      """ruby
+      RSpec.describe "eager loading with subject!" do
+        subject! { element_list.push(99) }
+
+        let(:element_list) { [1, 2, 3] }
+
+        it "calls the definition block before the example" do
+          element_list.push(5)
+          expect(element_list).to eq([1, 2, 3, 99, 5])
+        end
+      end
+      """
+    When I run `rspec subject_bang_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Use `subject(:name)` to define a memoized helper method
+    **Note:** While a global variable is used in the examples below, this behavior is strongly
+    discouraged in actual specs. It is used here simply to demonstrate the value will be
+    cached across multiple calls in the same example but not across examples.
+    Given a file named "named_subject_spec.rb" with:
+      """ruby
+      $count = 0
+
+      RSpec.describe "named subject" do
+        subject(:global_count) { $count += 1 }
+
+        it "is memoized across calls (i.e. the block is invoked once)" do
+          expect {
+            2.times { global_count }
+          }.not_to change{ global_count }.from(1)
+        end
+
+        it "is not cached across examples" do
+          expect(global_count).to eq(2)
+        end
+
+        it "is still available using the subject method" do
+          expect(subject).to eq(3)
+        end
+
+        it "works with the one-liner syntax" do
+          is_expected.to eq(4)
+        end
+
+        it "the subject and named helpers return the same object" do
+          expect(global_count).to be(subject)
+        end
+
+        it "is set to the block return value (i.e. the global $count)" do
+          expect(global_count).to be($count)
+        end
+      end
+      """
+    When I run `rspec named_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Use `subject!(:name)` to define a helper method called before the example
+    Given a file named "named_subject_bang_spec.rb" with:
+      """ruby
+      RSpec.describe "eager loading using a named subject!" do
+        subject!(:updated_list) { element_list.push(99) }
+
+        let(:element_list) { [1, 2, 3] }
+
+        it "calls the definition block before the example" do
+          element_list.push(5)
+          expect(element_list).to eq([1, 2, 3, 99, 5])
+          expect(updated_list).to be(element_list)
+        end
+      end
+      """
+    When I run `rspec named_subject_bang_spec.rb`
+    Then the examples should all pass

data/rspec-core/upstream/features/subject/implicit_subject.feature

@@ -0,0 +1,57 @@
+Feature: implicitly defined subject
+
+  If the first argument to the outermost example group is a class, an instance
+  of that class is exposed to each example via the `subject` method.
+
+  While the examples below demonstrate how `subject` can be used as a
+  user-facing concept, we recommend that you reserve it for support of custom
+  matchers and/or extension libraries that hide its use from examples.
+
+  Scenario: `subject` exposed in top level group
+    Given a file named "top_level_subject_spec.rb" with:
+      """ruby
+      RSpec.describe Array do
+        it "should be empty when first created" do
+          expect(subject).to be_empty
+        end
+      end
+      """
+    When I run `rspec ./top_level_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: `subject` in a nested group
+    Given a file named "nested_subject_spec.rb" with:
+      """ruby
+      RSpec.describe Array do
+        describe "when first created" do
+          it "should be empty" do
+            expect(subject).to be_empty
+          end
+        end
+      end
+      """
+    When I run `rspec nested_subject_spec.rb`
+    Then the examples should all pass
+
+  Scenario: `subject` in a nested group with a different class (innermost wins)
+    Given a file named "nested_subject_spec.rb" with:
+      """ruby
+      class ArrayWithOneElement < Array
+        def initialize(*)
+          super
+          unshift "first element"
+        end
+      end
+
+      RSpec.describe Array do
+        describe ArrayWithOneElement do
+          context "referenced as subject" do
+            it "contains one element" do
+              expect(subject).to include("first element")
+            end
+          end
+        end
+      end
+      """
+    When I run `rspec nested_subject_spec.rb`
+    Then the examples should all pass

data/rspec-core/upstream/features/subject/one_liner_syntax.feature

@@ -0,0 +1,69 @@
+@oneliner-should
+Feature: One-liner syntax
+
+  RSpec supports a one-liner syntax for setting an expectation on the
+  `subject`.  RSpec will give the examples a doc string that is auto-
+  generated from the matcher used in the example. This is designed specifically
+  to help avoid duplication in situations where the doc string and the matcher
+  used in the example mirror each other exactly. When used excessively, it can
+  produce documentation output that does not read well or contribute to
+  understanding the object you are describing.
+
+  This comes in two flavors:
+
+    * `is_expected` is defined simply as `expect(subject)` and is designed for
+      when you are using rspec-expectations with its newer expect-based syntax.
+    * `should` was designed back when rspec-expectations only had a should-based
+      syntax. However, it continues to be available and work even if the
+      `:should` syntax is disabled (since that merely removes `Object#should`
+      but this is `RSpec::Core::ExampleGroup#should`).
+
+  Note: this feature is only available when using rspec-expectations.
+
+  Scenario: Implicit subject
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe Array do
+        describe "when first created" do
+          # Rather than:
+          # it "should be empty" do
+          #   subject.should be_empty
+          # end
+
+          it { should be_empty }
+          # or
+          it { is_expected.to be_empty }
+        end
+      end
+      """
+    When I run `rspec example_spec.rb --format doc`
+    Then the examples should all pass
+     And the output should contain:
+       """
+       Array
+         when first created
+           should be empty
+           should be empty
+       """
+
+  Scenario: Explicit subject
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe Array do
+        describe "with 3 items" do
+          subject { [1,2,3] }
+          it { should_not be_empty }
+          # or
+          it { is_expected.not_to be_empty }
+        end
+      end
+      """
+    When I run `rspec example_spec.rb --format doc`
+    Then the examples should all pass
+     And the output should contain:
+       """
+       Array
+         with 3 items
+           should not be empty
+           should not be empty
+       """

data/rspec-core/upstream/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/upstream/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/upstream/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/upstream/lib/rspec/autorun.rb

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

data/rspec-core/upstream/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