opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/matchers/built_in/yield.rb

@@ -0,0 +1,297 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class YieldProbe
+        def self.probe(block)
+          probe = new
+          assert_valid_expect_block!(block)
+          block.call(probe)
+          probe.assert_used!
+          probe
+        end
+
+        attr_accessor :num_yields, :yielded_args
+
+        def initialize
+          @used = false
+          self.num_yields, self.yielded_args = 0, []
+        end
+
+        def to_proc
+          @used = true
+
+          probe = self
+          Proc.new do |*args|
+            probe.num_yields += 1
+            probe.yielded_args << args
+            nil # to indicate the block does not return a meaningful value
+          end
+        end
+
+        def single_yield_args
+          yielded_args.first
+        end
+
+        def yielded_once?(matcher_name)
+          case num_yields
+          when 1 then true
+          when 0 then false
+          else
+            raise "The #{matcher_name} matcher is not designed to be used with a " +
+                  "method that yields multiple times. Use the yield_successive_args " +
+                  "matcher for that case."
+          end
+        end
+
+        def successive_yield_args
+          yielded_args.map do |arg_array|
+            arg_array.size == 1 ? arg_array.first : arg_array
+          end
+        end
+
+        def assert_used!
+          return if @used
+          raise "You must pass the argument yielded to your expect block on " +
+                "to the method-under-test as a block. It acts as a probe that " +
+                "allows the matcher to detect whether or not the method-under-test " +
+                "yields, and, if so, how many times, and what the yielded arguments " +
+                "are."
+        end
+
+        def self.assert_valid_expect_block!(block)
+          return if block.arity == 1
+          raise "Your expect block must accept an argument to be used with this " +
+                "matcher. Pass the argument as a block on to the method you are testing."
+        end
+      end
+
+      class YieldControl < BaseMatcher
+        def initialize
+          @expectation_type = nil
+          @expected_yields_count = nil
+        end
+
+        def matches?(block)
+          probe = YieldProbe.probe(block)
+
+          if @expectation_type
+            probe.num_yields.send(@expectation_type, @expected_yields_count)
+          else
+            probe.yielded_once?(:yield_control)
+          end
+        end
+
+        def once
+          exactly(1)
+          self
+        end
+
+        def twice
+          exactly(2)
+          self
+        end
+
+        def exactly(number)
+          set_expected_yields_count(:==, number)
+          self
+        end
+
+        def at_most(number)
+          set_expected_yields_count(:<=, number)
+          self
+        end
+
+        def at_least(number)
+          set_expected_yields_count(:>=, number)
+          self
+        end
+
+        def times
+          self
+        end
+
+        def failure_message_for_should
+          'expected given block to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
+        end
+
+        def failure_message_for_should_not
+          'expected given block not to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
+        end
+
+        private
+
+        def set_expected_yields_count(relativity, n)
+          @expectation_type = relativity
+          @expected_yields_count = case n
+                                   when Numeric then n
+                                   when :once then 1
+                                   when :twice then 2
+                                   end
+        end
+
+        def relativity_failure_message
+          return '' unless @expected_yields_count
+          " #{human_readable_expecation_type}#{human_readable_count}"
+        end
+
+        def human_readable_expecation_type
+          case @expectation_type
+          when :<= then 'at most '
+          when :>= then 'at least '
+          else ''
+          end
+        end
+
+        def human_readable_count
+          case @expected_yields_count
+          when 1 then "once"
+          when 2 then "twice"
+          else "#{@expected_yields_count} times"
+          end
+        end
+      end
+
+      class YieldWithNoArgs < BaseMatcher
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.empty?
+        end
+
+        def failure_message_for_should
+          "expected given block to yield with no arguments, but #{failure_reason}"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield with no arguments, but did"
+        end
+
+      private
+
+        def failure_reason
+          if @probe.num_yields.zero?
+            "did not yield"
+          else
+            "yielded with arguments: #{@probe.single_yield_args.inspect}"
+          end
+        end
+      end
+
+      class YieldWithArgs
+        def initialize(*args)
+          @expected = args
+        end
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @actual = @probe.single_yield_args
+          @probe.yielded_once?(:yield_with_args) && args_match?
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected given block to yield with arguments, but #{positive_failure_reason}"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield with arguments, but #{negative_failure_reason}"
+        end
+
+        def description
+          desc = "yield with args"
+          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")" unless @expected.empty?
+          desc
+        end
+
+      private
+
+        def positive_failure_reason
+          if @probe.num_yields.zero?
+            "did not yield"
+          else
+            @positive_args_failure
+          end
+        end
+
+        def negative_failure_reason
+          if all_args_match?
+            "yielded with expected arguments" +
+              "\nexpected not: #{@expected.inspect}" +
+              "\n         got: #{@actual.inspect} (compared using === and ==)"
+          else
+            "did"
+          end
+        end
+
+        def args_match?
+          if @expected.empty? # expect {...}.to yield_with_args
+            @positive_args_failure = "yielded with no arguments" if @actual.empty?
+            return !@actual.empty?
+          end
+
+          unless match = all_args_match?
+            @positive_args_failure = "yielded with unexpected arguments" +
+              "\nexpected: #{@expected.inspect}" +
+              "\n     got: #{@actual.inspect} (compared using === and ==)"
+          end
+
+          match
+        end
+
+        def all_args_match?
+          return false if @expected.size != @actual.size
+
+          @expected.zip(@actual).all? do |expected, actual|
+            expected === actual || actual == expected
+          end
+        end
+      end
+
+      class YieldSuccessiveArgs
+        def initialize(*args)
+          @expected = args
+        end
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @actual = @probe.successive_yield_args
+          args_match?
+        end
+        alias == matches?
+
+        def failure_message_for_should
+          "expected given block to yield successively with arguments, but yielded with unexpected arguments" +
+            "\nexpected: #{@expected.inspect}" +
+            "\n     got: #{@actual.inspect} (compared using === and ==)"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield successively with arguments, but yielded with expected arguments" +
+              "\nexpected not: #{@expected.inspect}" +
+              "\n         got: #{@actual.inspect} (compared using === and ==)"
+        end
+
+        def description
+          desc = "yield successive args"
+          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")"
+          desc
+        end
+
+      private
+
+        def args_match?
+          return false if @expected.size != @actual.size
+
+          @expected.zip(@actual).all? do |expected, actual|
+            expected === actual || actual == expected
+          end
+        end
+      end
+    end
+  end
+end
+

data/vendor_lib/rspec/matchers/built_in.rb

@@ -0,0 +1,39 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      require 'rspec/matchers/built_in/base_matcher'
+      autoload :BeAnInstanceOf, 'rspec/matchers/built_in/be_instance_of'
+      autoload :Be,             'rspec/matchers/built_in/be'
+      autoload :BeTruthy,         'rspec/matchers/built_in/be'
+      autoload :BeFalsey,        'rspec/matchers/built_in/be'
+      autoload :BeNil,          'rspec/matchers/built_in/be'
+      autoload :BeComparedTo,   'rspec/matchers/built_in/be'
+      autoload :BePredicate,    'rspec/matchers/built_in/be'
+      autoload :BeAKindOf,      'rspec/matchers/built_in/be_kind_of'
+      autoload :BeWithin,       'rspec/matchers/built_in/be_within'
+      autoload :Change,         'rspec/matchers/built_in/change'
+      autoload :Cover,          'rspec/matchers/built_in/cover' if (1..2).respond_to?(:cover?)
+      autoload :Eq,             'rspec/matchers/built_in/eq'
+      autoload :Eql,            'rspec/matchers/built_in/eql'
+      autoload :Equal,          'rspec/matchers/built_in/equal'
+      autoload :Exist,          'rspec/matchers/built_in/exist'
+      autoload :Has,            'rspec/matchers/built_in/has'
+      autoload :Have,           'rspec/matchers/built_in/have'
+      autoload :Include,        'rspec/matchers/built_in/include'
+      autoload :Match,          'rspec/matchers/built_in/match'
+      autoload :MatchArray,     'rspec/matchers/built_in/match_array'
+      autoload :RaiseError,     'rspec/matchers/built_in/raise_error'
+      autoload :RespondTo,      'rspec/matchers/built_in/respond_to'
+      autoload :StartWith,      'rspec/matchers/built_in/start_and_end_with'
+      autoload :EndWith,        'rspec/matchers/built_in/start_and_end_with'
+      autoload :Satisfy,        'rspec/matchers/built_in/satisfy'
+      autoload :ThrowSymbol,    'rspec/matchers/built_in/throw_symbol'
+      autoload :YieldControl,   'rspec/matchers/built_in/yield'
+      autoload :YieldWithArgs,  'rspec/matchers/built_in/yield'
+      autoload :YieldWithNoArgs, 'rspec/matchers/built_in/yield'
+      autoload :YieldSuccessiveArgs, 'rspec/matchers/built_in/yield'
+    end
+  end
+end
+
+

data/vendor_lib/rspec/matchers/compatibility.rb

@@ -0,0 +1,14 @@
+RSpec::Matchers.constants.each do |c|
+  if Class === (klass = RSpec::Matchers.const_get(c))
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
+      klass.class_exec do
+        alias_method :failure_message, :failure_message_for_should
+      end
+    end
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
+      klass.class_exec do
+        alias_method :negative_failure_message, :failure_message_for_should_not
+      end
+    end
+  end
+end

data/vendor_lib/rspec/matchers/configuration.rb

@@ -0,0 +1,113 @@
+require 'rspec/expectations/syntax'
+
+module RSpec
+  module Matchers
+    # Provides configuration options for rspec-expectations.
+    class Configuration
+      # Configures the supported syntax.
+      # @param [Array<Symbol>, Symbol] values the syntaxes to enable
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.expect_with :rspec do |c|
+      #       c.syntax = :should
+      #       # or
+      #       c.syntax = :expect
+      #       # or
+      #       c.syntax = [:should, :expect]
+      #     end
+      #   end
+      def syntax=(values)
+        if Array(values).include?(:expect)
+          Expectations::Syntax.enable_expect
+        else
+          Expectations::Syntax.disable_expect
+        end
+
+        if Array(values).include?(:should)
+          Expectations::Syntax.enable_should
+        else
+          Expectations::Syntax.disable_should
+        end
+      end
+
+      # The list of configured syntaxes.
+      # @return [Array<Symbol>] the list of configured syntaxes.
+      def syntax
+        syntaxes = []
+        syntaxes << :should if Expectations::Syntax.should_enabled?
+        syntaxes << :expect if Expectations::Syntax.expect_enabled?
+        syntaxes
+      end
+
+      # color config for expectations
+      # fallback if rspec core not available
+      if ::RSpec.respond_to?(:configuration)
+        def color?
+          ::RSpec.configuration.color_enabled?
+        end
+      else
+        attr_writer :color
+        def color?
+          @color
+        end
+      end
+
+      # Adds `should` and `should_not` to the given classes
+      # or modules. This can be used to ensure `should` works
+      # properly on things like proxy objects (particular
+      # `Delegator`-subclassed objects on 1.8).
+      #
+      # @param [Array<Module>] modules the list of classes or modules
+      #   to add `should` and `should_not` to.
+      def add_should_and_should_not_to(*modules)
+        modules.each do |mod|
+          Expectations::Syntax.enable_should(mod)
+        end
+      end
+
+      # Sets or gets the backtrace formatter. The backtrace formatter should
+      # implement `#format_backtrace(Array<String>)`. This is used
+      # to format backtraces of errors handled by the `raise_error`
+      # matcher.
+      #
+      # If you are using rspec-core, rspec-core's backtrace formatting
+      # will be used (including respecting the presence or absence of
+      # the `--backtrace` option).
+      #
+      # @overload backtrace_formatter
+      #   @return [#format_backtrace] the backtrace formatter
+      # @overload backtrace_formatter=
+      #   @param value [#format_backtrace] sets the backtrace formatter
+      attr_writer :backtrace_formatter
+      def backtrace_formatter
+        @backtrace_formatter ||= if defined?(::RSpec::Core::BacktraceFormatter)
+          ::RSpec::Core::BacktraceFormatter
+        else
+          NullBacktraceFormatter
+        end
+      end
+
+      def reset_syntaxes_to_default
+        self.syntax = [:should, :expect]
+        RSpec::Expectations::Syntax.warn_about_should!
+      end
+
+      # @api private
+      NullBacktraceFormatter = Module.new do
+        def self.format_backtrace(backtrace)
+          backtrace
+        end
+      end
+    end
+
+    # The configuration object
+    # @return [RSpec::Matchers::Configuration] the configuration object
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    # set default syntax
+    configuration.reset_syntaxes_to_default
+  end
+end
+

data/vendor_lib/rspec/matchers/dsl.rb

@@ -0,0 +1,23 @@
+module RSpec
+  module Matchers
+    module DSL
+      # Defines a custom matcher.
+      # @see RSpec::Matchers
+      def define(name, &declarations)
+        define_method name do |*expected|
+          matcher = RSpec::Matchers::DSL::Matcher.new(name, declarations, *expected)
+          matcher.matcher_execution_context = @matcher_execution_context ||= self
+          matcher
+        end
+      end
+
+      alias_method :matcher, :define
+
+      if RSpec.respond_to?(:configure)
+        RSpec.configure {|c| c.extend self}
+      end
+    end
+  end
+end
+
+RSpec::Matchers.extend RSpec::Matchers::DSL

data/vendor_lib/rspec/matchers/generated_descriptions.rb

@@ -0,0 +1,35 @@
+module RSpec
+  module Matchers
+    class << self
+      attr_accessor :last_matcher, :last_should
+    end
+
+    def self.clear_generated_description
+      self.last_matcher = nil
+      self.last_should = nil
+    end
+
+    def self.generated_description
+      return nil if last_should.nil?
+      "#{last_should.to_s.gsub('_',' ')} #{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 { object.should matcher }
+
+or this:
+
+it { should 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