rspec-expectations 2.14.0 → 3.13.0

data/features/test_frameworks/test_unit.feature

@@ -1,44 +0,0 @@
-Feature: Test::Unit integration
-
-  RSpec-expectations is a stand-alone gem that can be used without the rest of
-  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
-  prefer RSpec's approach to expressing expectations, you can have both.
-
-  The one downside is that failures are reported as errors with MiniTest.
-
-  Scenario: use rspec/expectations with Test::Unit
-    Given a file named "rspec_expectations_test.rb" with:
-      """ruby
-      require 'test/unit'
-      require 'rspec/expectations'
-
-      class RSpecExpectationsTest < Test::Unit::TestCase
-        RSpec::Matchers.define :be_an_integer do
-          match { |actual| Integer === actual }
-        end
-
-        def be_an_int
-          # This is actually an internal rspec-expectations API, but is used
-          # here to demonstrate that deprecation warnings from within
-          # rspec-expectations work correcty without depending on rspec-core
-          RSpec.deprecate(:be_an_int, :replacement => :be_an_integer)
-          be_an_integer
-        end
-
-        def test_passing_expectation
-          expect(1 + 3).to eq 4
-        end
-
-        def test_failing_expectation
-          expect([1,2]).to be_empty
-        end
-
-        def test_custom_matcher_with_deprecation_warning
-          expect(1).to be_an_int
-        end
-      end
-      """
-     When I run `ruby rspec_expectations_test.rb`
-     Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
-      And the output should contain "expected empty? to return true, got false"
-      And the output should contain "be_an_int is deprecated"

data/lib/rspec/expectations/deprecation.rb

@@ -1,17 +0,0 @@
-module RSpec
-  module Expectations
-    module Deprecation
-      # @private
-      #
-      # Used internally to print deprecation warnings
-      def deprecate(deprecated, options={})
-        message = "DEPRECATION: #{deprecated} is deprecated."
-        message << " Use #{options[:replacement]} instead." if options[:replacement]
-        message << " Called from #{caller(0)[2]}."
-        warn message
-      end
-    end
-  end
-
-  extend(Expectations::Deprecation) unless respond_to?(:deprecate)
-end

data/lib/rspec/expectations/differ.rb

@@ -1,133 +0,0 @@
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-require 'pp'
-
-module RSpec
-  module Expectations
-    class Differ
-      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(input_data_new, input_data_old)
-        output = matching_encoding("", input_data_old)
-        data_old = input_data_old.split(matching_encoding("\n", input_data_old)).map! { |e| e.chomp }
-        data_new = input_data_new.split(matching_encoding("\n", input_data_new)).map! { |e| e.chomp }
-        diffs = Diff::LCS.diff(data_old, data_new)
-        return output if diffs.empty?
-        oldhunk = hunk = nil
-        file_length_difference = 0
-        diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(
-              data_old, data_new, piece, context_lines, file_length_difference
-            )
-            file_length_difference = hunk.file_length_difference
-            next unless oldhunk
-            # Hunks may overlap, which is why we need to be careful when our
-            # diff includes lines of context. Otherwise, we might print
-            # redundant lines.
-            if (context_lines > 0) and hunk.overlaps?(oldhunk)
-              if hunk.respond_to?(:merge)
-                # diff-lcs 1.2.x
-                hunk.merge(oldhunk)
-              else
-                # diff-lcs 1.1.3
-                hunk.unshift(oldhunk)
-              end
-            else
-              output << matching_encoding(oldhunk.diff(format).to_s, output)
-            end
-          ensure
-            oldhunk = hunk
-            output << matching_encoding("\n", output)
-          end
-        end
-        #Handle the last remaining hunk
-        output << matching_encoding(oldhunk.diff(format).to_s,output)
-        output << matching_encoding("\n",output)
-        color_diff output
-      rescue Encoding::CompatibilityError
-        if input_data_new.encoding != input_data_old.encoding
-          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
-          "differs from the encoding of the expected string (#{input_data_new.encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
-        end
-      end
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        if diff = diff_as_string(actual_as_string, expected_as_string)
-          color_diff diff
-        end
-      end
-
-    protected
-
-      def format
-        :unified
-      end
-
-      def context_lines
-        3
-      end
-
-      def color(text, color_code)
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-
-      def red(text)
-        color(text, 31)
-      end
-
-      def green(text)
-        color(text, 32)
-      end
-
-      def blue(text)
-        color(text, 34)
-      end
-
-      def color_diff(diff)
-        return diff unless RSpec::Matchers.configuration.color?
-
-        diff.lines.map { |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : line
-          else
-            line
-          end
-        }.join
-      end
-
-      def object_to_string(object)
-        case object
-        when Hash
-          object.keys.sort_by { |k| k.to_s }.map do |k|
-            %(#{PP.singleline_pp(k, "")} => #{PP.singleline_pp(object[k], "")})
-          end.join(",\n")
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object,"")
-        end
-      end
-
-      if String.method_defined?(:encoding)
-        def matching_encoding(string, source)
-          string.encode(source.encoding)
-        end
-      else
-        def matching_encoding(string, source)
-          string
-        end
-      end
-    end
-
-  end
-end
-

data/lib/rspec/expectations/errors.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Expectations
-    if defined?(Test::Unit::AssertionFailedError)
-      class ExpectationNotMetError < Test::Unit::AssertionFailedError; end
-    else
-      class ExpectationNotMetError < ::StandardError; end
-    end
-  end
-end

data/lib/rspec/expectations/extensions/array.rb

@@ -1,9 +0,0 @@
-# @private
-class Array
-  unless public_instance_methods.map {|m| m.to_s}.include?('none?')
-    # Supports +none?+ on early patch levels of Ruby 1.8.6
-    def none?(&block)
-      !any?(&block)
-    end
-  end
-end

data/lib/rspec/expectations/extensions/object.rb

@@ -1,29 +0,0 @@
-module RSpec
-  module Expectations
-    module DeprecatedConstants
-      # Displays deprecation warning when it captures Rspec and Spec. Otherwise
-      # delegates to super.
-      def const_missing(name)
-        case name
-        when :Rspec, :Spec
-          RSpec.deprecate(name.to_s, :replacement => "RSpec")
-          RSpec
-        else
-          begin
-            super
-          rescue Exception => e
-            e.backtrace.reject! {|l| l =~ Regexp.compile(__FILE__) }
-            raise e
-          end
-        end
-      end
-    end
-
-    # @deprecated (no replacement)
-    def differ=(ignore)
-      RSpec.deprecate("RSpec::Expectations.differ=(differ)")
-    end
-  end
-end
-
-extend RSpec::Expectations::DeprecatedConstants

data/lib/rspec/expectations/extensions.rb

@@ -1,2 +0,0 @@
-require 'rspec/expectations/extensions/array'
-require 'rspec/expectations/extensions/object'

data/lib/rspec/matchers/be_close.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Matchers
-    # @deprecated use +be_within+ instead.
-    def be_close(expected, delta)
-      RSpec.deprecate("be_close(#{expected}, #{delta})", :replacement => "be_within(#{delta}).of(#{expected})")
-      be_within(delta).of(expected)
-    end
-  end
-end

data/lib/rspec/matchers/built_in/have.rb

@@ -1,124 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Have
-        QUERY_METHODS = [:size, :length, :count].freeze
-
-        def initialize(expected, relativity=:exactly)
-          @expected = case expected
-                      when :no then 0
-                      when String then expected.to_i
-                      else expected
-                      end
-          @relativity = relativity
-          @actual = @collection_name = @plural_collection_name = nil
-        end
-
-        def relativities
-          @relativities ||= {
-            :exactly => "",
-            :at_least => "at least ",
-            :at_most => "at most "
-          }
-        end
-
-        def matches?(collection_or_owner)
-          collection = determine_collection(collection_or_owner)
-          case collection
-          when enumerator_class
-            for query_method in QUERY_METHODS
-              next unless collection.respond_to?(query_method)
-              @actual = collection.__send__(query_method)
-              break unless @actual.nil?
-            end
-            raise not_a_collection if @actual.nil?
-          else
-            query_method = determine_query_method(collection)
-            raise not_a_collection unless query_method
-            @actual = collection.__send__(query_method)
-          end
-          case @relativity
-          when :at_least then @actual >= @expected
-          when :at_most  then @actual <= @expected
-          else                @actual == @expected
-          end
-        end
-        alias == matches?
-
-        def determine_collection(collection_or_owner)
-          if collection_or_owner.respond_to?(@collection_name)
-            collection_or_owner.__send__(@collection_name, *@args, &@block)
-          elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
-            collection_or_owner.__send__(@plural_collection_name, *@args, &@block)
-          elsif determine_query_method(collection_or_owner)
-            collection_or_owner
-          else
-            collection_or_owner.__send__(@collection_name, *@args, &@block)
-          end
-        end
-
-        def determine_query_method(collection)
-          QUERY_METHODS.detect {|m| collection.respond_to?(m)}
-        end
-
-        def not_a_collection
-          "expected #{@collection_name} to be a collection but it does not respond to #length, #size or #count"
-        end
-
-        def failure_message_for_should
-          "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
-        end
-
-        def failure_message_for_should_not
-          if @relativity == :exactly
-            return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
-          elsif @relativity == :at_most
-            return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  #{Expectations::Syntax.negative_expression("actual", "have_at_most(#{@expected}).#{@collection_name}")}
-We recommend that you use this instead:
-  #{Expectations::Syntax.positive_expression("actual", "have_at_least(#{@expected + 1}).#{@collection_name}")}
-EOF
-          elsif @relativity == :at_least
-            return <<-EOF
-Isn't life confusing enough?
-Instead of having to figure out the meaning of this:
-  #{Expectations::Syntax.negative_expression("actual", "have_at_least(#{@expected}).#{@collection_name}")}
-We recommend that you use this instead:
-  #{Expectations::Syntax.positive_expression("actual", "have_at_most(#{@expected - 1}).#{@collection_name}")}
-EOF
-          end
-        end
-
-        def description
-          "have #{relative_expectation} #{@collection_name}"
-        end
-
-        def respond_to?(m)
-          @expected.respond_to?(m) || super
-        end
-
-        private
-
-        def method_missing(method, *args, &block)
-          @collection_name = method
-          if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
-            @plural_collection_name = inflector.pluralize(method.to_s)
-          end
-          @args = args
-          @block = block
-          self
-        end
-
-        def relative_expectation
-          "#{relativities[@relativity]}#{@expected}"
-        end
-
-        def enumerator_class
-          RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
-        end
-      end
-    end
-  end
-end

data/lib/rspec/matchers/built_in/match_array.rb

@@ -1,51 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class MatchArray < BaseMatcher
-        def match(expected, actual)
-          return false unless actual.respond_to? :to_ary
-          @extra_items = difference_between_arrays(actual, expected)
-          @missing_items = difference_between_arrays(expected, actual)
-          @extra_items.empty? & @missing_items.empty?
-        end
-
-        def failure_message_for_should
-          if actual.respond_to? :to_ary
-            message =  "expected collection contained:  #{safe_sort(expected).inspect}\n"
-            message += "actual collection contained:    #{safe_sort(actual).inspect}\n"
-            message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
-            message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
-          else
-            message = "expected an array, actual collection was #{actual.inspect}"
-          end
-
-          message
-        end
-
-        def failure_message_for_should_not
-          "Matcher does not support should_not"
-        end
-
-        def description
-          "contain exactly #{_pretty_print(expected)}"
-        end
-
-        private
-
-        def safe_sort(array)
-          array.sort rescue array
-        end
-
-        def difference_between_arrays(array_1, array_2)
-          difference = array_1.to_ary.dup
-          array_2.to_ary.each do |element|
-            if index = difference.index(element)
-              difference.delete_at(index)
-            end
-          end
-          difference
-        end
-      end
-    end
-  end
-end

data/lib/rspec/matchers/built_in/start_and_end_with.rb

@@ -1,48 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class StartAndEndWith < BaseMatcher
-        def initialize(*expected)
-          @expected = expected.length == 1 ? expected.first : expected
-        end
-
-        def matches?(actual)
-          @actual = actual.respond_to?(:[]) ? actual : (raise ArgumentError.new("#{actual.inspect} does not respond to :[]"))
-          begin
-            @expected.respond_to?(:length) ? subset_matches?(@expected, @actual) : element_matches?(@expected, @actual)
-          rescue ArgumentError
-            raise ArgumentError.new("#{actual.inspect} does not have ordered elements")
-          end
-        end
-
-        def failure_message_for_should
-          "expected #{@actual.inspect} to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
-        end
-
-        def failure_message_for_should_not
-          "expected #{@actual.inspect} not to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
-        end
-      end
-
-      class StartWith < StartAndEndWith
-        def subset_matches?(expected, actual)
-          actual[0, expected.length] == expected
-        end
-
-        def element_matches?(expected, actual)
-          @actual[0] == @expected
-        end
-      end
-
-      class EndWith < StartAndEndWith
-        def subset_matches?(expected, actual)
-          actual[-expected.length, expected.length] == expected
-        end
-
-        def element_matches?(expected, actual)
-          actual[-1] == expected
-        end
-      end
-    end
-  end
-end

data/lib/rspec/matchers/compatibility.rb

@@ -1,14 +0,0 @@
-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_eval 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_eval do
-        alias_method :negative_failure_message, :failure_message_for_should_not
-      end
-    end
-  end
-end

data/lib/rspec/matchers/configuration.rb

@@ -1,108 +0,0 @@
-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
-
-      # @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.syntax = [:expect, :should]
-  end
-end
-

data/lib/rspec/matchers/extensions/instance_eval_with_args.rb

@@ -1,39 +0,0 @@
-module RSpec
-  module Matchers
-    module Extensions
-      module InstanceEvalWithArgs
-        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
-        # http://eigenclass.org/hiki/bounded+space+instance_exec
-        # - uses singleton_class instead of global InstanceExecHelper module
-        # - this keeps it scoped to classes/modules that include this module
-        # - only necessary for ruby 1.8.6
-        def instance_eval_with_args(*args, &block)
-          return instance_exec(*args, &block) if respond_to?(:instance_exec)
-
-          # If there are no args and the block doesn't expect any, there's no
-          # need to fake instance_exec with our hack below.
-          # Notes:
-          #   * lambda { }.arity # => -1
-          #   * lambda { || }.arity # => 0
-          #   * lambda { |*a| }.arity # -1
-          return instance_eval(&block) if block.arity < 1 && args.empty?
-
-          singleton_class = (class << self; self; end)
-          begin
-            orig_critical, Thread.critical = Thread.critical, true
-            n = 0
-            n += 1 while respond_to?(method_name="__instance_exec#{n}")
-            singleton_class.module_eval{ define_method(method_name, &block) }
-          ensure
-            Thread.critical = orig_critical
-          end
-          begin
-            return __send__(method_name, *args)
-          ensure
-            singleton_class.module_eval{ remove_method(method_name) } rescue nil
-          end
-        end
-      end
-    end
-  end
-end