opal-connect-rspec 0.5.0

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

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

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

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

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

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