rspec-expectations 2.11.3 → 3.11.0

data/features/test_frameworks/test_unit.feature

@@ -1,46 +0,0 @@
-Feature: Test::Unit integration
-
-  RSpec-expectations is a stand-alone gem that can be used without
-  the rest of RSpec.  It can easily be used with another test
-  framework such as Test::Unit if you like RSpec's should/should_not
-  syntax but prefer the test organization of another framework.
-
-  Scenario: Basic Test::Unit usage
-    Given a file named "rspec_expectations_test.rb" with:
-      """
-      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
-          RSpec.deprecate(:be_an_int, :be_an_integer)
-          be_an_integer
-        end
-
-        def test_passing_expectation
-          x = 1 + 3
-          x.should == 4
-        end
-
-        def test_failing_expectation
-          array = [1, 2]
-          array.should be_empty
-        end
-
-        def test_expect_matcher
-          expect { @a = 5 }.to change { @a }.from(nil).to(5)
-        end
-
-        def test_custom_matcher_and_deprecation_warning
-          1.should be_an_int
-        end
-      end
-      """
-     When I run `ruby rspec_expectations_test.rb`
-     Then the output should contain "4 tests, 0 assertions, 1 failures, 0 errors" or "4 tests, 0 assertions, 0 failures, 1 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,38 +0,0 @@
-module RSpec
-  unless respond_to?(:deprecate)
-    class << self
-      # Used internally by RSpec to display standard deprecation warnings.
-      # This is also defined in rspec-core, but we can't assume it's loaded
-      # since rspec-expectations should be usable w/o rspec-core.
-      def deprecate(method, alternate_method=nil, version=nil)
-        version_string = version ? "rspec-#{version}" : "a future version of RSpec"
-
-        message = <<-NOTICE
-
-*****************************************************************
-DEPRECATION WARNING: you are using deprecated behaviour that will
-be removed from #{version_string}.
-
-#{caller(0)[2]}
-
-* #{method} is deprecated.
-NOTICE
-      if alternate_method
-        message << <<-ADDITIONAL
-* please use #{alternate_method} instead.
-ADDITIONAL
-      end
-
-        message << "*****************************************************************"
-        warn_deprecation(message)
-      end
-
-      # Used internally by RSpec to display custom deprecation warnings.  This
-      # is also defined in rspec-core, but we can't assume it's loaded since
-      # rspec-expectations should be usable w/o rspec-core.
-      def warn_deprecation(message)
-        send :warn, message
-      end
-    end
-  end
-end

data/lib/rspec/expectations/differ.rb

@@ -1,81 +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(data_new, data_old)
-        data_old = data_old.split(/\n/).map! { |e| e.chomp }
-        data_new = data_new.split(/\n/).map! { |e| e.chomp }
-        diffs = Diff::LCS.diff(data_old, data_new)
-        output = ""
-        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)
-              hunk.unshift(oldhunk)
-            else
-              output << oldhunk.diff(format)
-            end
-          ensure
-            oldhunk = hunk
-            output << "\n"
-          end
-        end
-        #Handle the last remaining hunk
-        output << oldhunk.diff(format) << "\n"
-      end
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        diff = diff_as_string(actual_as_string, expected_as_string)
-
-        if diff.empty?
-          "#{actual}.==(#{expected}) returned false even though the diff " \
-          "between #{actual} and #{expected} is empty. Check the " \
-          "implementation of #{actual}.==."
-        else
-          diff
-        end
-      end
-
-    protected
-
-      def format
-        :unified
-      end
-
-      def context_lines
-        3
-      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
-    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,39 +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.warn_deprecation <<-WARNING
-*****************************************************************
-DEPRECATION WARNING: you are using a deprecated constant that will
-be removed from a future version of RSpec.
-
-#{caller(0)[2]}
-
-* #{name} is deprecated.
-* RSpec is the new top-level module in RSpec-2
-***************************************************************
-WARNING
-          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)", "nothing at all (diffing is now automatic and no longer configurable)")
-    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})", "be_within(#{delta}).of(#{expected})")
-      be_within(delta).of(expected)
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Have
-        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)
-          query_method = determine_query_method(collection)
-          raise not_a_collection unless query_method
-          @actual = collection.send(query_method)
-          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)
-          [:size, :length, :count].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:
-  should_not have_at_most(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
-  should 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:
-  should_not have_at_least(#{@expected}).#{@collection_name}
-We recommend that you use this instead:
-  should 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
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class MatchArray < BaseMatcher
-        def match(expected, actual)
-          @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
-          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?
-          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.dup
-          array_2.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,66 +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
-
-      # 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
-    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