messagebus_ruby_api 0.4.0 → 0.4.4

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

@@ -0,0 +1,213 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,84 @@
+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

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

@@ -0,0 +1,59 @@
+module RR
+  module MethodDispatches
+    class MethodDispatch < BaseMethodDispatch
+      attr_reader :double_injection, :subject
+      def initialize(double_injection, subject, args, block)
+        @double_injection, @subject, @args, @block = double_injection, subject, args, block
+        @double = find_double_to_attempt
+      end
+
+      def call
+        space.record_call(subject, method_name, args, block)
+        if double
+          double.method_call(args)
+          call_yields
+          return_value_1 = call_implementation
+          return_value_2 = extract_subject_from_return_value(return_value_1)
+          if after_call_proc
+            extract_subject_from_return_value(after_call_proc.call(return_value_2))
+          else
+            return_value_2
+          end
+        else
+          double_not_found_error
+        end
+      end
+
+      def call_original_method
+        if subject_has_original_method?
+          subject.__send__(original_method_alias_name, *args, &block)
+        elsif subject_has_original_method_missing?
+          call_original_method_missing
+        else
+          subject.__send__(:method_missing, method_name, *args, &block)
+        end
+      end
+
+      protected
+      def call_implementation
+        if implementation_is_original_method?
+          call_original_method
+        else
+          if implementation
+            if implementation.is_a?(Method)
+              implementation.call(*args, &block)
+            else
+              call_args = block ? args + [ProcFromBlock.new(&block)] : args
+              implementation.call(*call_args)
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      def_delegators :definition, :implementation
+      def_delegators :double_injection, :subject_has_original_method?, :subject_has_original_method_missing?, :method_name, :original_method_alias_name
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module RR
+  module MethodDispatches
+    class MethodMissingDispatch < BaseMethodDispatch
+      extend(Module.new do
+        def original_method_missing_alias_name
+          "__rr__original_method_missing"
+        end
+      end)
+
+      attr_reader :subject, :subject_class, :method_name
+      def initialize(subject, subject_class, method_name, args, block)
+        @subject, @subject_class, @method_name, @args, @block = subject, subject_class, method_name, args, block
+      end
+
+      def call
+        if Injections::DoubleInjection.exists?(subject_class, method_name)
+          @double = find_double_to_attempt
+          if double
+            return_value = extract_subject_from_return_value(call_implementation)
+            if after_call_proc
+              extract_subject_from_return_value(after_call_proc.call(return_value))
+            else
+              return_value
+            end
+          else
+            double_not_found_error
+          end
+        else
+          call_original_method
+        end
+      end
+
+      def call_original_method
+        Injections::DoubleInjection.find_or_create(subject_class, method_name).dispatch_method_delegates_to_dispatch_original_method do
+          call_original_method_missing
+        end
+      end
+
+      protected
+      def call_implementation
+        if implementation_is_original_method?
+          space.record_call(subject, method_name, args, block)
+          double.method_call(args)
+          call_original_method
+        else
+          if double_injection = Injections::DoubleInjection.find(subject_class, method_name)
+            double_injection.bind_method
+            # The DoubleInjection takes care of calling double.method_call
+            subject.__send__(method_name, *args, &block)
+          else
+            nil
+          end
+        end
+      end
+
+      def double_injection
+        Injections::DoubleInjection.find_or_create(subject_class, method_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module RR
+  class ProcFromBlock < Proc
+    def ==(other)
+      Proc.new(&self) == other
+    end
+  end
+end