Dispatcher refactored.

Author: ThomasNunninger

src/Magic/Dispatcher.php

@@ -57,7 +57,8 @@ public static function invoke(
         array $prioritizedCallHandlerClassNames
     )
     {
-        return self::doInvocation($object, $methodName, $arguments, $prioritizedCallHandlerClassNames, false);
+        return self::instance()
+            ->doInvocation($object, $methodName, $arguments, $prioritizedCallHandlerClassNames, false);
     }
 
     public static function invokeStatically(
@@ -67,59 +68,41 @@ public static function invokeStatically(
         array $prioritizedCallHandlerClassNames
     )
     {
-        return self::doInvocation($className, $methodName, $arguments, $prioritizedCallHandlerClassNames, true);
+        return self::instance()
+            ->doInvocation($className, $methodName, $arguments, $prioritizedCallHandlerClassNames, true);
     }
 
     /**
      * @param object|string $objectOrClassName
      */
-    private static function doInvocation(
+    private function doInvocation(
         $objectOrClassName,
         string $methodName,
         array $arguments,
-        array $prioritizedCallHandlerClassNames,
+        array $prioritizedCallHandlers,
         bool $isStatic
     )
     {
-        $instance = self::instance();
-
         $className = $isStatic ? $objectOrClassName : get_class($objectOrClassName);
-        $classMetadata = $instance->classMetadata($className);
+        $classMetadata = $this->classMetadata($className);
 
-        foreach ($prioritizedCallHandlerClassNames as $callHandlerData) {
-            // prepare $callHandlerClassName and $options
-            if (is_array($callHandlerData)) {
-                $callHandlerClassName = $callHandlerData[0];
-                $options = $callHandlerData[1];
-            } else {
-                $callHandlerClassName = $callHandlerData;
-                $options = [];
-            }
+        $callHandler = $this->determineCallHandler($methodName, $classMetadata, $prioritizedCallHandlers);
 
-            // retrieve $callHandler
-            if (! array_key_exists($callHandlerClassName, $instance->callHandlers)) {
-                $instance->callHandlers[$callHandlerClassName] = new $callHandlerClassName();
+        if (! is_null($callHandler)) {
+            if (
+                $isStatic &&
+                $callHandler->requiresObjectContext()
+            ) {
+                throw new \Error("Calling a non-static method when not in object context.");
             }
 
-            $callHandler = $instance->callHandlers[$callHandlerClassName];
-
-            // execute
-            if ($callHandler->canHandle($methodName, $classMetadata, $options)) {
-                $instance->assertGivenParametersMatchMethodSignature($methodName, $arguments, $classMetadata);
-
-                if (
-                    $isStatic &&
-                    $callHandler->requiresObjectContext()
-                ) {
-                    throw new \Error("Calling a non-static method when not in object context.");
-                }
+            $this->assertGivenParametersMatchMethodSignature($methodName, $arguments, $classMetadata);
 
-                $return = $callHandler->execute($objectOrClassName, $methodName, $arguments, $classMetadata);
+            $return = $callHandler->execute($objectOrClassName, $methodName, $arguments, $classMetadata);
 
-                $instance->assertCorrectReturnType($objectOrClassName, $methodName, $return, $classMetadata);
+            $this->assertCorrectReturnType($objectOrClassName, $methodName, $return, $classMetadata);
 
-                return $return;
-            }
+            return $return;
         }
 
         if (
@@ -144,6 +127,37 @@ private function classMetadata(string $className) : ClassMetadata
             ->classMetadata[$className];
     }
 
+    private function determineCallHandler(
+        string $methodName,
+        ClassMetadata $classMetadata,
+        array $prioritizedCallHandlers
+    ) : ?CallHandler
+    {
+        foreach ($prioritizedCallHandlers as $callHandlerData) {
+            // prepare $callHandlerClassName and $options
+            if (is_array($callHandlerData)) {
+                $callHandlerClassName = $callHandlerData[0];
+                $options = $callHandlerData[1];
+            } else {
+                $callHandlerClassName = $callHandlerData;
+                $options = [];
+            }
+
+            // retrieve $callHandler
+            if (! array_key_exists($callHandlerClassName, $this->callHandlers)) {
+                $this->callHandlers[$callHandlerClassName] = new $callHandlerClassName();
+            }
+            $callHandler = $this->callHandlers[$callHandlerClassName];
+
+            // check if it can handle the method
+            if ($callHandler->canHandle($methodName, $classMetadata, $options)) {
+                return $callHandler;
+            }
+        }
+
+        return null;
+    }
+
     private function assertGivenParametersMatchMethodSignature(
         string $methodName,
         array $parameters,

tests/PhpUnit/Magic/DispatcherTest.php

@@ -32,6 +32,7 @@ final class DispatcherTest extends TestCase
      * @covers ::classMetadata()
      * @covers ::invoke()
      * @covers ::doInvocation()
+     * @covers ::determineCallHandler()
      * @covers ::assertGivenParametersMatchMethodSignature()
      * @covers ::assertCorrectReturnType()
      */
@@ -91,6 +92,22 @@ public function it_invokes_a_virtual_static_method_on_some_object_via_some_call_
         );
     }
 
+    /**
+     * @test
+     * @covers ::determineCallHandler()
+     */
+    public function it_accepts_call_handlers_with_options()
+    {
+        // given a ClassName with a CallHandler that has options (like the NamedConstructor in
+        // ClassForNamedConstructorTesting)
+
+        // when determining the CallHandler
+        $newObject = ClassForNamedConstructorTesting::create('some other string', 11);
+
+        // then the relevant options have been used
+        $this->assertInstanceOf(ClassForNamedConstructorTesting::class, $newObject);
+    }
+
     /**
      * @test
      * @covers ::doInvocation()
@@ -203,6 +220,7 @@ public function it_throws_an_exception_when_the_return_type_is_invalid()
     /**
      * @test
      * @covers ::doInvocation()
+     * @covers ::determineCallHandler()
      */
     public function it_throws_an_exception_if_no_call_handler_can_handle_the_method()
     {