opal-rspec 0.6.2 → 0.7.0.rc.1

data/rspec-expectations/lib/rspec/matchers/generated_descriptions.rb

@@ -1,42 +0,0 @@
-module RSpec
-  module Matchers
-    class << self
-      # @private
-      attr_accessor :last_matcher, :last_expectation_handler
-    end
-
-    # @api private
-    # Used by rspec-core to clear the state used to generate
-    # descriptions after an example.
-    def self.clear_generated_description
-      self.last_matcher = nil
-      self.last_expectation_handler = nil
-    end
-
-    # @api private
-    # Generates an an example description based on the last expectation.
-    # Used by rspec-core's one-liner syntax.
-    def self.generated_description
-      return nil if last_expectation_handler.nil?
-      "#{last_expectation_handler.verb} #{last_description}"
-    end
-
-  private
-
-    def self.last_description
-      last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
-When you call a matcher in an example without a String, like this:
-
-specify { expect(object).to matcher }
-
-or this:
-
-it { is_expected.to matcher }
-
-RSpec expects the matcher to have a #description method. You should either
-add a String to the example this matcher is being used in, or give it a
-description method. Then you won't have to suffer this lengthy warning again.
-MESSAGE
-    end
-  end
-end

data/rspec-expectations/lib/rspec/matchers/matcher_delegator.rb

@@ -1,33 +0,0 @@
-module RSpec
-  module Matchers
-    # Provides the necessary plumbing to wrap a matcher with a decorator.
-    # @private
-    class MatcherDelegator
-      include Composable
-      attr_reader :base_matcher
-
-      def initialize(base_matcher)
-        @base_matcher = base_matcher
-      end
-
-      def method_missing(*args, &block)
-        base_matcher.__send__(*args, &block)
-      end
-
-      if ::RUBY_VERSION.to_f > 1.8
-        def respond_to_missing?(name, include_all=false)
-          super || base_matcher.respond_to?(name, include_all)
-        end
-      else
-        def respond_to?(name, include_all=false)
-          super || base_matcher.respond_to?(name, include_all)
-        end
-      end
-
-      def initialize_copy(other)
-        @base_matcher = @base_matcher.clone
-        super
-      end
-    end
-  end
-end

data/rspec-expectations/lib/rspec/matchers/matcher_protocol.rb

@@ -1,99 +0,0 @@
-module RSpec
-  module Matchers
-    # rspec-expectations can work with any matcher object that implements this protocol.
-    #
-    # @note This class is not loaded at runtime by rspec-expectations. It exists
-    #   purely to provide documentation for the matcher protocol.
-    class MatcherProtocol
-      # @!group Required Methods
-
-      # @method matches?
-      # @param actual [Object] The object being matched against.
-      # @yield For an expression like `expect(x).to matcher do...end`, the `do/end`
-      #   block binds to `to`. It passes that block, if there is one, on to this method.
-      # @return [Boolean] true if this matcher matches the provided object.
-
-      # @method failure_message
-      # This will only be called if {#matches?} returns false.
-      # @return [String] Explanation for the failure.
-
-      # @!endgroup
-
-      # @!group Optional Methods
-
-      # @method does_not_match?
-      # In a negative expectation such as `expect(x).not_to foo`, RSpec will
-      # call `foo.does_not_match?(x)` if this method is defined. If it's not
-      # defined it will fall back to using `!foo.matches?(x)`. This allows you
-      # to provide custom logic for the negative case.
-      #
-      # @param actual [Object] The object being matched against.
-      # @yield For an expression like `expect(x).not_to matcher do...end`, the `do/end`
-      #   block binds to `not_to`. It passes that block, if there is one, on to this method.
-      # @return [Boolean] true if this matcher does not match the provided object.
-
-      # @method failure_message_when_negated
-      # This will only be called when a negative match fails.
-      # @return [String] Explanation for the failure.
-      # @note This method is listed as optional because matchers do not have to
-      #   support negation. But if your matcher does support negation, this is a
-      #   required method -- otherwise, you'll get a `NoMethodError`.
-
-      # @method description
-      # The description is used for two things:
-      #
-      #   * When using RSpec's one-liner syntax
-      #     (e.g. `it { is_expected.to matcher }`), the description
-      #     is used to generate the example's doc string since you
-      #     have not provided one.
-      #   * In a composed matcher expression, the description is used
-      #     as part of the failure message (and description) of the outer
-      #     matcher.
-      #
-      # @return [String] Description of the matcher.
-
-      # @method supports_block_expectations?
-      # Indicates that this matcher can be used in a block expectation expression,
-      # such as `expect { foo }.to raise_error`. Generally speaking, this is
-      # only needed for matchers which operate on a side effect of a block, rather
-      # than on a particular object.
-      # @return [Boolean] true if this matcher can be used in block expressions.
-      # @note If not defined, RSpec assumes a value of `false` for this method.
-
-      # @method expects_call_stack_jump?
-      # Indicates that when this matcher is used in a block expectation
-      # expression, it expects the block to use a ruby construct that causes
-      # a call stack jump (such as raising an error or throwing a symbol).
-      #
-      # This is used internally for compound block expressions, as matchers
-      # which expect call stack jumps must be treated with care to work properly.
-      #
-      # @return [Boolean] true if the matcher expects a call stack jump
-      #
-      # @note This method is very rarely used or needed.
-      # @note If not defined, RSpec assumes a value of `false` for this method.
-
-      # @method diffable?
-      # @return [Boolean] true if `actual` and `expected` can be diffed.
-      # Indicates that this matcher provides `actual` and `expected` attributes,
-      # and that the values returned by these can be usefully diffed, which can
-      # be included in the output.
-
-      # @method actual
-      # @return [String, Object] If an object (rather than a string) is provided,
-      #   RSpec will use the `pp` library to convert it to multi-line output in
-      #   order to diff.
-      # The actual value for the purposes of a diff.
-      # @note This method is required if `diffable?` returns true.
-
-      # @method expected
-      # @return [String, Object] If an object (rather than a string) is provided,
-      #   RSpec will use the `pp` library to convert it to multi-line output in
-      #   order to diff.
-      # The expected value for the purposes of a diff.
-      # @note This method is required if `diffable?` returns true.
-
-      # @!endgroup
-    end
-  end
-end

data/rspec-expectations/lib/rspec/matchers/pretty.rb

@@ -1,77 +0,0 @@
-module RSpec
-  module Matchers
-    # @api private
-    # Contains logic to facilitate converting ruby symbols and
-    # objects to english phrases.
-    module Pretty
-      # @api private
-      # Converts a symbol into an english expression.
-      def split_words(sym)
-        sym.to_s.gsub(/_/, ' ')
-      end
-      module_function :split_words
-
-      # @api private
-      # Converts a collection of objects into an english expression.
-      def to_sentence(words)
-        return " #{words.inspect}" if !words || Struct === words
-        words = Array(words).map { |w| to_word(w) }
-        case words.length
-        when 0
-          ""
-        when 1
-          " #{words[0]}"
-        when 2
-          " #{words[0]} and #{words[1]}"
-        else
-          " #{words[0...-1].join(', ')}, and #{words[-1]}"
-        end
-      end
-
-      # @api private
-      # Converts the given item to string suitable for use in a list expression.
-      def to_word(item)
-        is_matcher_with_description?(item) ? item.description : item.inspect
-      end
-
-      # @private
-      # Provides an English expression for the matcher name.
-      def name_to_sentence
-        split_words(name)
-      end
-
-      # @api private
-      # Provides a name for the matcher.
-      def name
-        defined?(@name) ? @name : underscore(self.class.name.split("::").last)
-      end
-
-      # @private
-      # Borrowed from ActiveSupport
-      def underscore(camel_cased_word)
-        word = camel_cased_word.to_s.dup
-        word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-        word.tr!("-", "_")
-        word.downcase!
-        word
-      end
-
-    private
-
-      def is_matcher_with_description?(object)
-        RSpec::Matchers.is_a_matcher?(object) && object.respond_to?(:description)
-      end
-
-      # `{ :a => 5, :b => 2 }.inspect` produces:
-      #    {:a=>5, :b=>2}
-      # ...but it looks much better as:
-      #    {:a => 5, :b => 2}
-      #
-      # This is idempotent and safe to run on a string multiple times.
-      def improve_hash_formatting(inspect_string)
-        inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
-      end
-    end
-  end
-end

data/rspec-expectations/spec/rspec/expectations/configuration_spec.rb

@@ -1,226 +0,0 @@
-require 'delegate'
-
-module RSpec
-  module Expectations
-    RSpec.describe Configuration do
-      let(:config) { Configuration.new }
-
-      describe "#backtrace_formatter" do
-        let(:original_backtrace) { %w[ clean-me/a.rb other/file.rb clean-me/b.rb ] }
-        let(:cleaned_backtrace)  { %w[ other/file.rb ] }
-
-        let(:formatted_backtrace) do
-          config.backtrace_formatter.format_backtrace(original_backtrace)
-        end
-
-        before do
-          @old_patterns = RSpec.configuration.backtrace_exclusion_patterns
-          @orig_full_backtrace = RSpec.configuration.full_backtrace?
-          RSpec.configuration.full_backtrace = false
-          RSpec.configuration.backtrace_exclusion_patterns = [/clean-me/]
-        end
-
-        after do
-          RSpec.configuration.backtrace_exclusion_patterns = @old_patterns
-          RSpec.configuration.full_backtrace = @orig_full_backtrace
-        end
-
-        it "defaults to rspec-core's backtrace formatter when rspec-core is loaded" do
-          expect(config.backtrace_formatter).to be(RSpec.configuration.backtrace_formatter)
-          expect(formatted_backtrace).to eq(cleaned_backtrace)
-        end
-
-        it "defaults to a null formatter when rspec-core is not loaded" do
-          RSpec::Mocks.with_temporary_scope do
-            rspec_dup = ::RSpec.dup
-            class << rspec_dup; undef configuration; end
-            stub_const("RSpec", rspec_dup)
-
-            expect(formatted_backtrace).to eq(original_backtrace)
-          end
-        end
-
-        it "can be set to another backtrace formatter" do
-          config.backtrace_formatter = double(:format_backtrace => ['a'])
-          expect(formatted_backtrace).to eq(['a'])
-        end
-      end
-
-      context 'on an interpreter that does not provide BasicObject', :uses_should, :unless => defined?(::BasicObject) do
-        before { RSpec::Expectations::Syntax.disable_should(Delegator) }
-
-        let(:klass) do
-          Class.new(SimpleDelegator) do
-            def delegated?; true; end
-          end
-        end
-
-        let(:instance) { klass.new(Object.new) }
-
-        it 'provides a means to manually add it Delegator' do
-          instance.should_not respond_to(:delegated?) # because #should is being delegated...
-          config.add_should_and_should_not_to Delegator
-          instance.should respond_to(:delegated?) # now it should work!
-        end
-      end
-
-      describe "#include_chain_clauses_in_custom_matcher_descriptions?" do
-        it "is false by default" do
-          expect(config.include_chain_clauses_in_custom_matcher_descriptions?).to be false
-        end
-
-        it "can be set to true" do
-          config.include_chain_clauses_in_custom_matcher_descriptions = true
-          expect(config.include_chain_clauses_in_custom_matcher_descriptions?).to be true
-        end
-
-        it "can be set back to false" do
-          config.include_chain_clauses_in_custom_matcher_descriptions = true
-          config.include_chain_clauses_in_custom_matcher_descriptions = false
-          expect(config.include_chain_clauses_in_custom_matcher_descriptions?).to be false
-        end
-      end
-
-      shared_examples "configuring the expectation syntax" do
-        before do
-          @orig_syntax = RSpec::Matchers.configuration.syntax
-        end
-
-        after do
-          configure_syntax(@orig_syntax)
-        end
-
-        it 'can limit the syntax to :should' do
-          configure_syntax :should
-          configured_syntax.should eq([:should])
-
-          3.should eq(3)
-          3.should_not eq(4)
-          lambda { expect(6).to eq(6) }.should raise_error(NameError)
-        end
-
-        it 'is a no-op when configured to :should twice' do
-          configure_syntax :should
-          method_added_count = 0
-          allow(Expectations::Syntax.default_should_host).to receive(:method_added) { method_added_count += 1 }
-          configure_syntax :should
-
-          method_added_count.should eq(0)
-        end
-
-        it 'can limit the syntax to :expect' do
-          configure_syntax :expect
-          expect(configured_syntax).to eq([:expect])
-
-          expect(3).to eq(3)
-          expect { 3.should eq(3) }.to raise_error(NameError)
-          expect { 3.should_not eq(3) }.to raise_error(NameError)
-        end
-
-        it 'is a no-op when configured to :expect twice' do
-          allow(RSpec::Matchers).to receive(:method_added).and_raise("no methods should be added here")
-
-          configure_syntax :expect
-          configure_syntax :expect
-        end
-
-        describe "`:should` being enabled by default deprecation" do
-          before { configure_default_syntax }
-
-          it "warns when the should syntax is called by default" do
-            expected_arguments = [
-              /Using.*without explicitly enabling/,
-              {:replacement=>"the new `:expect` syntax or explicitly enable `:should`"}
-            ]
-
-            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
-            3.should eq(3)
-          end
-
-          it "includes the call site in the deprecation warning by default" do
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-            3.should eq(3)
-          end
-
-          it "does not warn when only the should syntax is explicitly configured" do
-            configure_syntax(:should)
-            RSpec.should_not receive(:deprecate)
-            3.should eq(3)
-          end
-
-          it "does not warn when both the should and expect syntaxes are explicitly configured" do
-            configure_syntax([:should, :expect])
-            expect(RSpec).not_to receive(:deprecate)
-            3.should eq(3)
-          end
-        end
-
-        it 'can re-enable the :should syntax' do
-          configure_syntax :expect
-          configure_syntax [:should, :expect]
-          configured_syntax.should eq([:should, :expect])
-
-          3.should eq(3)
-          3.should_not eq(4)
-          expect(3).to eq(3)
-        end
-
-        it 'can re-enable the :expect syntax' do
-          configure_syntax :should
-          configure_syntax [:should, :expect]
-          configured_syntax.should eq([:should, :expect])
-
-          3.should eq(3)
-          3.should_not eq(4)
-          expect(3).to eq(3)
-        end
-      end
-
-      def configure_default_syntax
-        RSpec::Matchers.configuration.reset_syntaxes_to_default
-      end
-
-      describe "configuring rspec-expectations directly" do
-        it_behaves_like "configuring the expectation syntax" do
-          def configure_syntax(syntax)
-            RSpec::Matchers.configuration.syntax = syntax
-          end
-
-          def configured_syntax
-            RSpec::Matchers.configuration.syntax
-          end
-        end
-      end
-
-      describe "configuring using the rspec-core config API" do
-        it_behaves_like "configuring the expectation syntax" do
-          def configure_syntax(syntax)
-            RSpec.configure do |rspec|
-              rspec.expect_with :rspec do |c|
-                c.syntax = syntax
-              end
-            end
-          end
-
-
-          def configured_syntax
-            RSpec.configure do |rspec|
-              rspec.expect_with :rspec do |c|
-                return c.syntax
-              end
-            end
-          end
-        end
-      end
-
-      it 'enables both syntaxes by default' do
-        # This is kinda a hack, but since we want to enforce use of
-        # the expect syntax within our specs here, we have modified the
-        # config setting, which makes it hard to get at the original
-        # default value. in spec_helper.rb we store the default value
-        # in $default_expectation_syntax so we can use it here.
-        expect($default_expectation_syntax).to contain_exactly(:expect, :should)
-      end
-    end
-  end
-end