messagebus_ruby_api 0.4.7 → 0.4.8

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr/injections/double_injection.rb

@@ -1,213 +0,0 @@
-module RR
-  module Injections
-    # RR::DoubleInjection is the binding of an subject and a method.
-    # A double_injection has 0 to many Double objects. Each Double
-    # has Argument Expectations and Times called Expectations.
-    class DoubleInjection < Injection
-      extend(Module.new do
-        def find_or_create(subject_class, method_name)
-          instances[subject_class][method_name.to_sym] ||= begin
-            new(subject_class, method_name.to_sym).bind
-          end
-        end
-
-        def find_or_create_by_subject(subject, method_name)
-          find_or_create(class << subject; self; end, method_name)
-        end
-
-        def find(subject_class, method_name)
-          instances[subject_class] && instances[subject_class][method_name.to_sym]
-        end
-
-        def find_by_subject(subject, method_name)
-          find(class << subject; self; end, method_name)
-        end
-
-        def exists?(subject_class, method_name)
-          !!find(subject_class, method_name)
-        end
-
-        def exists_by_subject?(subject, method_name)
-          exists?((class << subject; self; end), method_name)
-        end
-
-        def dispatch_method(subject, subject_class, method_name, arguments, block)
-          subject_eigenclass = (class << subject; self; end)
-          if (
-            exists?(subject_class, method_name) &&
-            (subject_class == subject_eigenclass) || !subject.is_a?(Class)
-          )
-            find(subject_class, method_name.to_sym).dispatch_method(subject, arguments, block)
-          else
-            new(subject_class, method_name.to_sym).dispatch_original_method(subject, arguments, block)
-          end
-        end
-
-        def reset
-          instances.each do |subject_class, method_double_map|
-            SingletonMethodAddedInjection.find(subject_class) && SingletonMethodAddedInjection.find(subject_class).reset
-            method_double_map.keys.each do |method_name|
-              reset_double(subject_class, method_name)
-            end
-            Injections::DoubleInjection.instances.delete(subject_class) if Injections::DoubleInjection.instances.has_key?(subject_class)
-          end
-        end
-
-        def verify(*subjects)
-          subject_classes = subjects.empty? ?
-            Injections::DoubleInjection.instances.keys :
-            subjects.map {|subject| class << subject; self; end}
-          subject_classes.each do |subject_class|
-            instances.include?(subject_class) &&
-              instances[subject_class].keys.each do |method_name|
-                verify_double(subject_class, method_name)
-              end &&
-              instances.delete(subject_class)
-          end
-        end
-
-        # Verifies the DoubleInjection for the passed in subject and method_name.
-        def verify_double(subject_class, method_name)
-          Injections::DoubleInjection.find(subject_class, method_name).verify
-        ensure
-          reset_double subject_class, method_name
-        end
-
-        # Resets the DoubleInjection for the passed in subject and method_name.
-        def reset_double(subject_class, method_name)
-          double_injection = Injections::DoubleInjection.instances[subject_class].delete(method_name)
-          double_injection.reset
-          Injections::DoubleInjection.instances.delete(subject_class) if Injections::DoubleInjection.instances[subject_class].empty?
-        end
-
-        def instances
-          @instances ||= HashWithObjectIdKey.new do |hash, subject_class|
-            hash.set_with_object_id(subject_class, {})
-          end
-        end
-      end)
-      include ClassInstanceMethodDefined
-
-      attr_reader :subject_class, :method_name, :doubles
-
-      MethodArguments = Struct.new(:arguments, :block)
-
-      def initialize(subject_class, method_name)
-        @subject_class = subject_class
-        @method_name = method_name.to_sym
-        @doubles = []
-        @dispatch_method_delegates_to_dispatch_original_method = nil
-      end
-
-      # RR::DoubleInjection#register_double adds the passed in Double
-      # into this DoubleInjection's list of Double objects.
-      def register_double(double)
-        @doubles << double
-      end
-
-      # RR::DoubleInjection#bind injects a method that acts as a dispatcher
-      # that dispatches to the matching Double when the method
-      # is called.
-      def bind
-        if subject_has_method_defined?(method_name)
-          bind_method_with_alias
-        else
-          Injections::MethodMissingInjection.find_or_create(subject_class)
-          Injections::SingletonMethodAddedInjection.find_or_create(subject_class)
-          bind_method_that_self_destructs_and_delegates_to_method_missing
-        end
-        self
-      end
-
-      def bind_method_that_self_destructs_and_delegates_to_method_missing
-        subject_class_object_id = subject_class.object_id
-        subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def #{method_name}(*args, &block)
-          ObjectSpace._id2ref(#{subject_class_object_id}).class_eval do
-            remove_method(:#{method_name})
-          end
-          method_missing(:#{method_name}, *args, &block)
-        end
-        RUBY
-        self
-      end
-
-      def bind_method
-        subject_class_object_id = subject_class.object_id
-        subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def #{method_name}(*args, &block)
-          arguments = MethodArguments.new(args, block)
-          RR::Injections::DoubleInjection.dispatch_method(self, ObjectSpace._id2ref(#{subject_class_object_id}), :#{method_name}, arguments.arguments, arguments.block)
-        end
-        RUBY
-        self
-      end
-
-      # RR::DoubleInjection#verify verifies each Double
-      # TimesCalledExpectation are met.
-      def verify
-        @doubles.each do |double|
-          double.verify
-        end
-      end
-
-      # RR::DoubleInjection#reset removes the injected dispatcher method.
-
-      # It binds the original method implementation on the subject
-      # if one exists.
-      def reset
-        if subject_has_original_method?
-          subject_class.__send__(:remove_method, method_name)
-          subject_class.__send__(:alias_method, method_name, original_method_alias_name)
-          subject_class.__send__(:remove_method, original_method_alias_name)
-        else
-          if subject_has_method_defined?(method_name)
-            subject_class.__send__(:remove_method, method_name)
-          end
-        end
-      end
-
-      def dispatch_method(subject, args, block)
-        if @dispatch_method_delegates_to_dispatch_original_method
-          dispatch_original_method(subject, args, block)
-        else
-          dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
-          dispatch.call
-        end
-      end
-
-      def dispatch_original_method(subject, args, block)
-        dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
-        dispatch.call_original_method
-      end
-
-      def subject_has_original_method_missing?
-        class_instance_method_defined(subject_class, MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name)
-      end
-
-      def original_method_alias_name
-        "__rr__original_#{@method_name}"
-      end
-
-      def dispatch_method_delegates_to_dispatch_original_method
-        @dispatch_method_delegates_to_dispatch_original_method = true
-        yield
-      ensure
-        @dispatch_method_delegates_to_dispatch_original_method = nil
-      end
-
-      protected
-      def deferred_bind_method
-        unless subject_has_method_defined?(original_method_alias_name)
-          bind_method_with_alias
-        end
-        @performed_deferred_bind = true
-      end
-
-      def bind_method_with_alias
-        subject_class.__send__(:alias_method, original_method_alias_name, method_name)
-        bind_method
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr/injections/injection.rb

@@ -1,33 +0,0 @@
-module RR
-  module Injections
-    class Injection
-      extend(Module.new do
-        def instances
-          @instances ||= HashWithObjectIdKey.new
-        end
-      end)
-
-      include Space::Reader
-      include ClassInstanceMethodDefined
-
-      def subject_has_method_defined?(method_name_in_question)
-        class_instance_method_defined(subject_class, method_name_in_question)
-      end
-
-      def subject_has_original_method?
-        subject_has_method_defined?(original_method_alias_name)
-      end
-
-      def original_method
-        subject_class.instance_method(original_method_alias_name)
-      end
-
-      protected
-      def subject_respond_to_method?(subject, method_name)
-        subject_has_method_defined?(method_name) ||
-          class_instance_method_defined(subject_class, :respond_to?) &&
-          subject.respond_to?(method_name)
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr/injections/method_missing_injection.rb

@@ -1,68 +0,0 @@
-module RR
-  module Injections
-    class MethodMissingInjection < Injection
-      extend(Module.new do
-        def find_or_create(subject_class)
-          instances[subject_class] ||= begin
-            new(subject_class).bind
-          end
-        end
-
-        def exists?(subject)
-          instances.include?(subject)
-        end
-      end)
-      include ClassInstanceMethodDefined
-
-      attr_reader :subject_class
-      def initialize(subject_class)
-        @subject_class = subject_class
-        @placeholder_method_defined = false
-      end
-
-      def bind
-        unless class_instance_method_defined(subject_class, original_method_alias_name)
-          unless class_instance_method_defined(subject_class, :method_missing)
-            @placeholder_method_defined = true
-            subject_class.class_eval do
-              def method_missing(method_name, *args, &block)
-                super
-              end
-            end
-          end
-          subject_class.__send__(:alias_method, original_method_alias_name, :method_missing)
-          bind_method
-        end
-        self
-      end
-
-      def reset
-        if subject_has_method_defined?(original_method_alias_name)
-          memoized_original_method_alias_name = original_method_alias_name
-          placeholder_method_defined = @placeholder_method_defined
-          subject_class.class_eval do
-            remove_method :method_missing
-            unless placeholder_method_defined
-              alias_method :method_missing, memoized_original_method_alias_name
-            end
-            remove_method memoized_original_method_alias_name
-          end
-        end
-      end
-
-      protected
-      def bind_method
-        subject_class_object_id = subject_class.object_id
-        subject_class.class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
-        def method_missing(method_name, *args, &block)
-          MethodDispatches::MethodMissingDispatch.new(self, ObjectSpace._id2ref(#{subject_class_object_id}), method_name, args, block).call
-        end
-        METHOD
-      end
-
-      def original_method_alias_name
-        MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr/injections/singleton_method_added_injection.rb

@@ -1,72 +0,0 @@
-module RR
-  module Injections
-    class SingletonMethodAddedInjection < Injection
-      extend(Module.new do
-        def find_or_create(subject_class)
-          instances[subject_class] ||= begin
-            new(subject_class).bind
-          end
-        end
-
-        def find(subject)
-          instances[subject]
-        end
-
-        def exists?(subject)
-          instances.include?(subject)
-        end
-      end)
-      include ClassInstanceMethodDefined
-
-      attr_reader :subject_class
-      def initialize(subject_class)
-        @subject_class = subject_class
-        @placeholder_method_defined = false
-      end
-
-      def bind
-        unless class_instance_method_defined(subject_class, original_method_alias_name, false)
-          unless class_instance_method_defined(subject_class, :singleton_method_added, false)
-            @placeholder_method_defined = true
-            subject_class.class_eval do
-              def singleton_method_added(method_name)
-                super
-              end
-            end
-          end
-
-          memoized_original_method_alias_name = original_method_alias_name
-          subject_class.__send__(:alias_method, original_method_alias_name, :singleton_method_added)
-          memoized_subject_class = subject_class
-          memoized_original_method_alias_name = original_method_alias_name
-          subject_class.__send__(:define_method, :singleton_method_added) do |method_name_arg|
-            if Injections::DoubleInjection.exists?(memoized_subject_class, method_name_arg)
-              Injections::DoubleInjection.find_or_create(memoized_subject_class, method_name_arg).send(:deferred_bind_method)
-            end
-            __send__(memoized_original_method_alias_name, method_name_arg)
-          end
-        end
-        self
-      end
-
-      def reset
-        if subject_has_method_defined?(original_method_alias_name)
-          memoized_original_method_alias_name = original_method_alias_name
-          placeholder_method_defined = @placeholder_method_defined
-          subject_class.class_eval do
-            remove_method :singleton_method_added
-            unless placeholder_method_defined
-              alias_method :singleton_method_added, memoized_original_method_alias_name
-            end
-            remove_method memoized_original_method_alias_name
-          end
-        end
-      end
-
-      protected
-      def original_method_alias_name
-        "__rr__original_singleton_method_added"
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -1,84 +0,0 @@
-module RR
-  module MethodDispatches
-    class BaseMethodDispatch
-      extend Forwardable
-      include Space::Reader
-
-      attr_reader :args, :block, :double
-
-      def call
-        raise NotImplementedError
-      end
-
-      protected
-      def find_double_to_attempt
-        matches = DoubleMatches.new(doubles).find_all_matches(args)
-
-        unless matches.exact_terminal_doubles_to_attempt.empty?
-          return matches.exact_terminal_doubles_to_attempt.first
-        end
-
-        unless matches.exact_non_terminal_doubles_to_attempt.empty?
-          return matches.exact_non_terminal_doubles_to_attempt.last
-        end
-
-        unless matches.wildcard_terminal_doubles_to_attempt.empty?
-          return matches.wildcard_terminal_doubles_to_attempt.first
-        end
-
-        unless matches.wildcard_non_terminal_doubles_to_attempt.empty?
-          return matches.wildcard_non_terminal_doubles_to_attempt.last
-        end
-
-        unless matches.matching_doubles.empty?
-          return matches.matching_doubles.first # This will raise a TimesCalledError
-        end
-
-        return nil
-      end
-
-      def call_yields
-        if definition.yields_value
-          if block
-            block.call(*definition.yields_value)
-          else
-            raise ArgumentError, "A Block must be passed into the method call when using yields"
-          end
-        end
-      end
-
-      def call_original_method_missing
-        subject.__send__(MethodMissingDispatch.original_method_missing_alias_name, method_name, *args, &block)
-      end
-
-      def implementation_is_original_method?
-        double.implementation_is_original_method?
-      end
-
-      def extract_subject_from_return_value(return_value)
-        case return_value
-          when DoubleDefinitions::DoubleDefinition
-            return_value.root_subject
-          when DoubleDefinitions::DoubleDefinitionCreateBlankSlate
-            return_value.__double_definition_create__.root_subject
-          else
-            return_value
-        end
-      end
-
-      def double_not_found_error
-        message =
-          "On subject #{subject},\n" <<
-          "unexpected method invocation:\n" <<
-          "  #{Double.formatted_name(method_name, args)}\n" <<
-          "expected invocations:\n" <<
-          Double.list_message_part(doubles)
-        raise Errors::DoubleNotFoundError, message
-      end
-
-      def_delegators :definition, :after_call_proc
-      def_delegators :double, :definition
-      def_delegators :double_injection, :doubles
-    end
-  end
-end