rr 1.1.1 → 3.0.0

data/VERSION

@@ -1 +0,0 @@
-1.1.1

data/lib/rr/adapters.rb

@@ -1,44 +0,0 @@
-module RR
-  module Adapters
-    class << self
-      DEPRECATED_ADAPTERS = [
-        :MiniTest,
-        :TestUnit
-      ]
-
-      def const_missing(adapter_const_name)
-        unless DEPRECATED_ADAPTERS.include?(adapter_const_name)
-          super
-          return
-        end
-
-        show_warning_for(adapter_const_name)
-
-        adapter = shim_adapters[adapter_const_name] ||=
-          case adapter_const_name
-            when :TestUnit
-              RR.find_applicable_adapter_matching(/^TestUnit/)
-            when :MiniTest
-              RR.find_applicable_adapter_matching(/^minitest/i)
-          end
-
-        adapter
-      end
-
-      private
-
-      def shim_adapters
-        @shim_adapters ||= {}
-      end
-
-      def show_warning_for(adapter_const_name)
-        warn <<EOT
---------------------------------------------------------------------------------
-RR deprecation warning: RR now has an autohook system. You don't need to
-`include RR::Adapters::*` in your test framework's base class anymore.
---------------------------------------------------------------------------------
-EOT
-      end
-    end
-  end
-end

data/lib/rr/adapters/rr_methods.rb

@@ -1,142 +0,0 @@
-module RR
-  module Adapters
-    module RRMethods
-      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
-
-      def mock(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.mock(subject, method_name, &definition_eval_block)
-      end
-
-      def stub(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.stub(subject, method_name, &definition_eval_block)
-      end
-
-      def dont_allow(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.dont_allow(subject, method_name, &definition_eval_block)
-      end
-
-      def proxy(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.proxy(subject, method_name, &definition_eval_block)
-      end
-
-      def strong(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.strong(subject, method_name, &definition_eval_block)
-      end
-
-      def instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.instance_of(subject, method_name, &definition_eval_block)
-      end
-
-      def any_instance_of(*args, &block)
-        RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
-      end
-
-      # Verifies all the DoubleInjection objects have met their
-      # TimesCalledExpectations.
-      def verify
-        RR::Space.instance.verify_doubles
-      end
-
-      # Resets the registered Doubles and ordered Doubles
-      def reset
-        RR::Space.instance.reset
-      end
-
-      # Returns a AnyTimesMatcher. This is meant to be passed in as an argument
-      # to Double#times.
-      #
-      #   mock(object).method_name(anything).times(any_times) {return_value}
-      def any_times
-        TimesCalledMatchers::AnyTimesMatcher.new
-      end
-
-      # Sets up an Anything wildcard ArgumentEqualityExpectation
-      # that succeeds when passed any argument.
-      #   mock(object).method_name(anything) {return_value}
-      #   object.method_name("an arbitrary value") # passes
-      def anything
-        RR::WildcardMatchers::Anything.new
-      end
-
-      # Sets up an IsA wildcard ArgumentEqualityExpectation
-      # that succeeds when passed an argument of a certain type.
-      #   mock(object).method_name(is_a(String)) {return_value}
-      #   object.method_name("A String") # passes
-      def is_a(klass)
-        RR::WildcardMatchers::IsA.new(klass)
-      end
-
-      # Sets up an Numeric wildcard ArgumentEqualityExpectation
-      # that succeeds when passed an argument that is ::Numeric.
-      #   mock(object).method_name(numeric) {return_value}
-      #   object.method_name(99) # passes
-      def numeric
-        RR::WildcardMatchers::Numeric.new
-      end
-
-      # Sets up an Boolean wildcard ArgumentEqualityExpectation
-      # that succeeds when passed an argument that is a ::Boolean.
-      #   mock(object).method_name(boolean) {return_value}
-      #   object.method_name(false) # passes
-      def boolean
-        RR::WildcardMatchers::Boolean.new
-      end
-
-      # Sets up a DuckType wildcard ArgumentEqualityExpectation
-      # that succeeds when the passed argument implements the methods.
-      #   arg = Object.new
-      #   def arg.foo; end
-      #   def arg.bar; end
-      #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
-      #   object.method_name(arg) # passes
-      def duck_type(*args)
-        RR::WildcardMatchers::DuckType.new(*args)
-      end
-
-      # Sets up a HashIncluding wildcard ArgumentEqualityExpectation
-      # that succeeds when the passed argument contains at least those keys
-      # and values of the expectation.
-      #   mock(object).method_name(hash_including(:foo => 1)) {return_value}
-      #   object.method_name({:foo => 1, :bar => 2) # passes
-      def hash_including(expected_hash)
-        RR::WildcardMatchers::HashIncluding.new(expected_hash)
-      end
-
-      # Sets up a Satisfy wildcard ArgumentEqualityExpectation
-      # that succeeds when the passed argument causes the expectation's
-      # proc to return true.
-      #   mock(object).method_name(satisfy {|arg| arg == :foo}) {return_value}
-      #   object.method_name(:foo) # passes
-      def satisfy(expectation_proc=nil, &block)
-        expectation_proc ||= block
-        RR::WildcardMatchers::Satisfy.new(expectation_proc)
-      end
-
-      def spy(subject)
-        methods_to_stub = subject.public_methods.map {|method_name| method_name.to_sym} -
-          [:methods, :==, :__send__, :__id__, :object_id, :class]
-        methods_to_stub.each do |method|
-          stub.proxy(subject, method)
-        end
-      end
-
-      def received(subject)
-        RR::SpyVerificationProxy.new(subject)
-      end
-
-      instance_methods.each do |name|
-        alias_method "rr_#{name}", name
-      end
-    end
-  end
-
-  module Extensions
-    InstanceMethods = Adapters::RRMethods
-  end
-end

data/lib/rr/integrations/rspec_1.rb

@@ -1,46 +0,0 @@
-module RR
-  module Integrations
-    class RSpec1
-      module Mixin
-        def setup_mocks_for_rspec
-          RR.reset
-        end
-
-        def verify_mocks_for_rspec
-          RR.verify
-        end
-
-        def teardown_mocks_for_rspec
-          RR.reset
-        end
-
-        def have_received(method = nil)
-          RSpec::InvocationMatcher.new(method)
-        end
-      end
-
-      def name
-        'RSpec 1'
-      end
-
-      def applies?
-        defined?(::Spec) &&
-        defined?(::Spec::VERSION::STRING) &&
-        ::Spec::VERSION::STRING =~ /^1/
-      end
-
-      def hook
-        ::Spec::Runner.configure do |config|
-          config.mock_with Mixin
-          config.include RR::Adapters::RRMethods
-        end
-        patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS
-        unless patterns.include?(RR::Errors::BACKTRACE_IDENTIFIER)
-          patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
-        end
-      end
-    end
-
-    RR.register_adapter RSpec1
-  end
-end

data/lib/rr/integrations/test_unit_1.rb

@@ -1,63 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit1
-      module Mixin
-        def assert_received(subject, &block)
-          block.call(received(subject)).call
-        end
-      end
-
-      def name
-        'Test::Unit 1'
-      end
-
-      def applies?
-        defined?(::Test::Unit) &&
-        defined?(::Test::Unit::TestCase) &&
-        !has_test_unit_version? &&
-        !test_unit_just_wraps_minitest?
-      end
-
-      def hook(test_case_class = ::Test::Unit::TestCase)
-        test_case_class.class_eval do
-          include RR::Adapters::RRMethods
-          include Mixin
-
-          unless instance_methods.detect {|method_name| method_name.to_sym == :setup_with_rr }
-            alias_method :setup_without_rr, :setup
-            def setup_with_rr
-              setup_without_rr
-              RR.reset
-              RR.trim_backtrace = true
-              RR.overridden_error_class = ::Test::Unit::AssertionFailedError
-            end
-            alias_method :setup, :setup_with_rr
-
-            alias_method :teardown_without_rr, :teardown
-            def teardown_with_rr
-              RR.verify
-            ensure
-              teardown_without_rr
-            end
-            alias_method :teardown, :teardown_with_rr
-          end
-        end
-      end
-
-      def test_unit_just_wraps_minitest?
-        defined?(::Test::Unit::TestCase) &&
-        defined?(::MiniTest::Unit::TestCase) &&
-        ::Test::Unit::TestCase < ::MiniTest::Unit::TestCase
-      end
-
-      def has_test_unit_version?
-        require 'test/unit/version'
-        true
-      rescue LoadError
-        false
-      end
-    end
-
-    RR.register_adapter TestUnit1
-  end
-end

data/lib/rr/integrations/test_unit_2.rb

@@ -1,15 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit2 < TestUnit1
-      def name
-        RR.ruby_18? ? 'Test::Unit 2.4.x' : 'Test::Unit >= 2.5'
-      end
-
-      def applies?
-        defined?(::Test::Unit) && has_test_unit_version?
-      end
-    end
-
-    RR.register_adapter TestUnit2
-  end
-end

data/lib/rr/integrations/test_unit_200.rb

@@ -1,27 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit200
-      def initialize
-        @mt4_adapter = RR.adapters_by_name[:MiniTest4]
-        @tu_adapter = RR.adapters_by_name[:TestUnit1]
-      end
-
-      def name
-        'Test::Unit 2.0.0'
-      end
-
-      def applies?
-        @mt4_adapter.applies? &&
-        defined?(::Test::Unit) &&
-        !@tu_adapter.has_test_unit_version? &&
-        @tu_adapter.test_unit_just_wraps_minitest?
-      end
-
-      def hook
-        @mt4_adapter.hook
-      end
-    end
-
-    RR.register_adapter TestUnit200
-  end
-end

data/lib/rr/integrations/test_unit_200_active_support.rb

@@ -1,25 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit200ActiveSupport
-      def initialize
-        @mt4as_adapter = RR.adapters_by_name[:MiniTest4ActiveSupport]
-        @tu200_adapter = RR.adapters_by_name[:TestUnit200]
-      end
-
-      def name
-        "#{@tu200_adapter.name} + ActiveSupport"
-      end
-
-      def applies?
-        @tu200_adapter.applies? && defined?(::ActiveSupport::TestCase)
-      end
-
-      def hook
-        @mt4as_adapter.hook
-      end
-    end
-
-    RR.register_adapter TestUnit200ActiveSupport
-  end
-end
-

data/lib/rr/integrations/test_unit_2_active_support.rb

@@ -1,38 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit2ActiveSupport
-      def initialize
-        @tu2_adapter = RR.adapters_by_name[:TestUnit2]
-      end
-
-      def name
-        "#{@tu2_adapter.name} + ActiveSupport"
-      end
-
-      def applies?
-        @tu2_adapter.applies? &&
-          defined?(::ActiveSupport::TestCase)
-      end
-
-      def hook
-        RR.trim_backtrace = true
-        RR.overridden_error_class = ::Test::Unit::AssertionFailedError
-
-        ::ActiveSupport::TestCase.class_eval do
-          include RR::Adapters::RRMethods
-          include TestUnit1::Mixin
-
-          setup do
-            RR.reset
-          end
-
-          teardown do
-            RR.verify
-          end
-        end
-      end
-    end
-
-    RR.register_adapter TestUnit2ActiveSupport
-  end
-end

data/lib/rr/proc_from_block.rb

@@ -1,11 +0,0 @@
-module RR
-  if RUBY_VERSION =~ /^1.8/
-    class ProcFromBlock < Proc
-      def ==(other)
-        Proc.new(&self) == other
-      end
-    end
-  else
-    ProcFromBlock = Proc
-  end
-end