rspec-expectations 2.99.2 → 3.0.0.beta1

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

@@ -1,273 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class Have
-        include MatchAliases
-
-        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
-          @target_owns_a_collection = false
-          @negative_expectation = false
-          @expectation_format_method = "to"
-        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)
-
-              if @actual
-                print_deprecation_message(query_method)
-                break
-              end
-            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)
-
-            print_deprecation_message(query_method)
-          end
-          case @relativity
-          when :at_least then @actual >= @expected
-          when :at_most  then @actual <= @expected
-          else                @actual == @expected
-          end
-        end
-
-        def does_not_match?(collection_or_owner)
-          @negative_expectation = true
-          @expectation_format_method = "to_not"
-          !matches?(collection_or_owner)
-        end
-
-        def determine_collection(collection_or_owner)
-          if collection_or_owner.respond_to?(@collection_name)
-            @target_owns_a_collection = true
-            collection_or_owner.__send__(@collection_name, *@args, &@block)
-          elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
-            @target_owns_a_collection = true
-            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
-
-        def print_deprecation_message(query_method)
-          deprecation_message = "the rspec-collection_matchers gem "
-          deprecation_message << "or replace your expectation with something like "
-          if for_rspec_rails_error_on?
-            # It is supposed to be safe to be able to convert the args array to
-            # a string. This is because the `errors_on` method only takes two
-            # valid arguments: attribute name (symbol/string) and a hash
-            deprecated_call = expectation_expression(query_method, "record")
-            deprecated_call << "(#{errors_on_args_list})" unless @args.empty?
-
-            deprecation_message << <<-EOS.gsub(/^\s+\|/, '')
-              |
-              |
-              |    #{record_valid_expression}
-              |    expect(#{record_errors_expression(query_method)}).#{expectation_format_method} #{suggested_matcher_expression}
-              |
-            EOS
-          else
-            deprecated_call = expectation_expression(query_method)
-            deprecation_message << "`expect(#{cardinality_expression(query_method)}).#{expectation_format_method} #{suggested_matcher_expression}`"
-          end
-
-          RSpec.deprecate("`#{deprecated_call}`",
-            :replacement => deprecation_message,
-            :type        => "the have matcher"
-          )
-        end
-
-        def expectation_expression(query_method, target = nil)
-          target ||= target_expression
-          if @negative_expectation
-            RSpec::Expectations::Syntax.negative_expression(target, original_matcher_expression)
-          else
-            RSpec::Expectations::Syntax.positive_expression(target, original_matcher_expression)
-          end
-        end
-
-        def target_expression
-          if @target_owns_a_collection
-            'collection_owner'
-          else
-            'collection'
-          end
-        end
-
-        def original_matcher_expression
-          "#{matcher_method}(#{@expected}).#{@collection_name}"
-        end
-
-        def expectation_format_method
-          if @relativity == :exactly
-            @expectation_format_method
-          else
-            "to"
-          end
-        end
-
-        def cardinality_expression(query_method)
-          expression = "#{target_expression}."
-          expression << "#{@collection_name}." if @target_owns_a_collection
-          expression << String(query_method)
-        end
-
-        def suggested_matcher_expression
-          send("suggested_matcher_expression_for_#{@relativity}")
-        end
-
-        def suggested_matcher_expression_for_exactly
-          "eq(#{@expected})"
-        end
-
-        def suggested_matcher_expression_for_at_most
-          if @negative_expectation
-            "be > #{@expected}"
-          else
-            "be <= #{@expected}"
-          end
-        end
-
-        def suggested_matcher_expression_for_at_least
-          if @negative_expectation
-            "be < #{@expected}"
-          else
-            "be >= #{@expected}"
-          end
-        end
-
-        def matcher_method
-          case @relativity
-          when :exactly
-            "have"
-          when :at_most
-            "have_at_most"
-          when :at_least
-            "have_at_least"
-          end
-        end
-
-        # RSpec Rails `errors_on` specific helpers
-        def for_rspec_rails_error_on?
-          defined?(RSpec::Rails) &&
-            /\.errors?_on\b/ =~ original_matcher_expression
-        end
-
-        def errors_on_args_list
-          list = @args.first.inspect
-          context = validation_context
-          list << ", :context => #{context}" if context
-          list
-        end
-
-        def record_valid_expression
-          expression = "record.valid?"
-          if on_context = validation_context
-            expression << "(#{on_context})"
-          end
-          expression
-        end
-
-        def validation_context
-          return unless Hash === @args.last
-          @args.last[:context].inspect
-        end
-
-        def record_errors_expression(query_method)
-          attribute = (@args.first || :attr)
-          "record.errors[#{attribute.inspect}].#{String(query_method)}"
-        end
-      end
-    end
-  end
-end

data/lib/rspec/matchers/differentiate_block_method_types.rb

@@ -1,55 +0,0 @@
-module RSpec
-  module Matchers
-    # Evaluates a block in order to determine what methods, if any,
-    # it defines as instance methods (using `def foo`) vs singleton
-    # methods (using `def self.foo`).
-    #
-    # @api private
-    class DifferentiateBlockMethodTypes
-      def initialize(*block_args, &block)
-        @block_args = block_args
-        @block = block
-
-        ignore_macro_methods
-
-        capture_added_methods(singletons_singleton_class, singleton_methods)
-        capture_added_methods(singleton_class, instance_methods)
-
-        singleton_class.class_exec(*block_args, &block)
-      end
-
-      def singleton_methods
-        @singleton_methods ||= []
-      end
-
-      def instance_methods
-        @instance_methods ||= []
-      end
-
-    private
-
-      def capture_added_methods(object, method_list)
-        object.__send__(:define_method, :singleton_method_added) do |method_name|
-          method_list << method_name
-        end
-
-        method_list.delete(:singleton_method_added)
-      end
-
-      unless method_defined?(:singleton_class)
-        def singleton_class
-          class << self; self; end
-        end
-      end
-
-      def singletons_singleton_class
-        class << singleton_class; self; end
-      end
-
-      def ignore_macro_methods
-        def singleton_class.method_missing(*); self; end
-      end
-    end
-  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

data/lib/rspec/matchers/match_aliases.rb

@@ -1,22 +0,0 @@
-module RSpec
-  module Matchers
-    module MatchAliases
-      def ==(other)
-        return true if equal?(other)
-
-        matched = matches?(other)
-
-        if matched
-          RSpec.deprecate("Using `matcher == value` as an alias for `#matches?`", :replacement => "`matcher === value`")
-        end
-
-        matched
-      end
-
-      def ===(other)
-        matches?(other)
-      end
-    end
-  end
-end
-

data/spec/rspec/matchers/be_close_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Matchers
-    describe "expect(actual).to be_close(expected, delta)" do
-      before(:each) do
-        allow(RSpec).to receive(:deprecate)
-      end
-
-      it "is deprecated" do
-        expect_deprecation_with_type('be_close(3.0, 0.5)',
-          'be_within(0.5).of(3.0)',
-          'the be_close matcher'
-        )
-        be_close(3.0, 0.5)
-      end
-
-      it "delegates to be_within(delta).of(expected)" do
-        should_receive(:be_within).with(0.5).and_return( be_within_matcher = double )
-        be_within_matcher.should_receive(:of).with(3.0)
-        be_close(3.0, 0.5)
-      end
-    end
-  end
-end

data/spec/rspec/matchers/differentiate_block_method_types_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Matchers
-    describe DifferentiateBlockMethodTypes do
-      let(:differentiator) do
-        DifferentiateBlockMethodTypes.new do
-          def some_instance_method_1; end
-          def self.some_singleton_method_1; end
-          define_method(:some_instance_method_2) { }
-
-          if RUBY_VERSION.to_f > 1.8
-            define_singleton_method(:some_singleton_method_2) { }
-          else
-            def self.some_singleton_method_2; end
-          end
-        end
-      end
-
-      it 'differentiates singleton method defs from instance method defs' do
-        expect(differentiator.instance_methods).to eq([:some_instance_method_1, :some_instance_method_2])
-        expect(differentiator.singleton_methods).to eq([:some_singleton_method_1, :some_singleton_method_2])
-      end
-
-      it 'passes the given args through to the block' do
-        expect { |b|
-          DifferentiateBlockMethodTypes.new(1, 2, &b)
-        }.to yield_with_args(1, 2)
-      end
-
-      it 'ignores unrecognized DSL methods called in the block' do
-        expect {
-          DifferentiateBlockMethodTypes.new { foo.bar; some_dsl { nested } }
-        }.not_to raise_error
-      end
-    end
-  end
-end
-