Accept routines passed as callable class names.

- Creates an execute() method in AbstractSyncedRoutine;
- Creates test for Respect\Rest\Routines\AbstractRoutine:
    - Add provider for valid constructor arguments
    - Add assert for getCallback() method on AbstractRoutine.

Author: Augusto Pascutti

library/Respect/Rest/Routines/AbstractRoutine.php

@@ -3,9 +3,6 @@
 namespace Respect\Rest\Routines;
 
 use InvalidArgumentException;
-use ReflectionFunction;
-use ReflectionMethod;
-use Respect\Rest\Routes\AbstractRoute;
 
 /** Base class for callback routines */
 abstract class AbstractRoutine implements Routinable
@@ -15,14 +12,17 @@ abstract class AbstractRoutine implements Routinable
 
     public function __construct($callback)
     {
+        if (is_string($callback) && class_exists($callback) && method_exists($callback, '__invoke'))
+            return $this->callback = $callback;
+
         if (!is_callable($callback))
             throw new InvalidArgumentException('Routine callback must be... guess what... callable!');
+
         $this->callback = $callback;
     }
 
     protected function getCallback()
     {
         return $this->callback;
     }
-
 }

library/Respect/Rest/Routines/AbstractSyncedRoutine.php

@@ -6,36 +6,65 @@
 use ReflectionFunction;
 use ReflectionMethod;
 use ReflectionObject;
+use ReflectionClass;
 use Closure;
-use Respect\Rest\Routes\AbstractRoute;
+use Respect\Rest\Routes\AbstractRoute,
+    Respect\Rest\Request;
 
 /** Base class for routines that sync parameters */
 abstract class AbstractSyncedRoutine extends AbstractRoutine implements ParamSynced
 {
-
+    /**
+     * @var Reflector
+     */
     protected $reflection;
 
+    /**
+     * Return parameters that can be used with the routine.
+     *
+     * @return array
+     */
     public function getParameters()
     {
         $reflection = $this->getReflection();
-        if (!$reflection instanceof ReflectionObject)
+        if (!$reflection instanceof ReflectionObject && !$reflection instanceof ReflectionClass)
             return $this->getReflection()->getParameters();
 
-        $constructorReflection = $reflection->getConstructor();
-        if (is_null($constructorReflection))
-            return array();
-        else
-            return $constructorReflection->getParameters();
+        return array();
+    }
+
+    /**
+     * Executes the routine and return its result.
+     *
+     * @param  Respect\Rest\Request $request
+     * @param  array  $params
+     * @return mixed
+     */
+    public function execute(Request $request, $params)
+    {
+        $callback = $this->getCallback();
+        if (is_string($callback)) {
+            $reflection      = $this->getReflection();
+            $routineInstance = $reflection->newInstanceArgs($params);
+            return $routineInstance();
+        }
+        return call_user_func_array($callback, $params);
     }
 
-    /** Returns a concrete ReflectionFunctionAbstract for this routine callback */
+    /**
+     * Returns a concrete ReflectionFunctionAbstract for this routine callback.
+     *
+     * @return Reflector
+     */
     protected function getReflection()
     {
         $callback = $this->getCallback();
         if (is_array($callback))
             return new ReflectionMethod($callback[0], $callback[1]);
         else if ($callback instanceof Closure)
             return new ReflectionFunction($callback);
+        else if (is_string($callback))
+            return new ReflectionClass($callback);
         else
             return new ReflectionObject($callback);
     }

library/Respect/Rest/Routines/By.php

@@ -10,7 +10,7 @@ class By extends AbstractSyncedRoutine implements ProxyableBy
 
     public function by(Request $request, $params)
     {
-        return call_user_func_array($this->callback, $params);
+        return $this->execute($request, $params);
     }
 
 }

library/Respect/Rest/Routines/Through.php

@@ -10,7 +10,7 @@ class Through extends AbstractSyncedRoutine implements ProxyableThrough
 
     public function through(Request $request, $params)
     {
-        return call_user_func_array($this->callback, $params);
+        return $this->execute($request, $params);
     }
 
 }

library/Respect/Rest/Routines/When.php

@@ -10,7 +10,7 @@ class When extends AbstractSyncedRoutine implements ProxyableWhen
 
     public function when(Request $request, $params)
     {
-        $valid = call_user_func_array($this->callback, $params);
+        $valid = $this->execute($request, $params);
 
         if (!$valid)
             header('HTTP/1.1 400');

tests/legacy/Respect/Rest/Routines/ByTest.php

@@ -44,6 +44,7 @@ public function test_by_with_an_anonymous_function()
 
     /**
      * @covers Respect\Rest\Routines\By
+     * @covers Respect\Rest\Routines\AbstractSyncedRoutine
      */
     public function test_by_on_a_route()
     {
@@ -57,6 +58,26 @@ public function test_by_on_a_route()
         );
     }
 
+    /**
+     * @covers Respect\Rest\Routines\By
+     * @covers Respect\Rest\Routines\AbstractSyncedRoutine
+     */
+    public function test_by_on_a_route_with_classname()
+    {
+        $router = new Router();
+        $router->get('/', function() { return 'route'; })
+               ->by('Stubs\Routines\ByClassWithInvoke');
+        // By does not affect the output of the route.
+        $this->assertEquals(
+            $expected = 'route',
+            (string) $router->dispatch('GET', '/')
+        );
+    }
+
+    /**
+     * @covers Respect\Rest\Routines\By
+     * @covers Respect\Rest\Routines\AbstractSyncedRoutine
+     */
     public function test_by_with_a_callable_class_on_a_route()
     {
         $router  = new Router;

tests/library/Respect/Rest/Routines/AbstractRoutineTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Respect\Rest\Routines;
+
+use InvalidArgumentException;
+use ReflectionFunction;
+use ReflectionMethod;
+use Stubs\Routines\AbstractRoutine as Stub;
+use Stubs\Routines\WhenAlwaysTrue as InstanceWithInvoke;
+
+/** Test an AbstractRoutine (abstract class) instantiation through a stub class. */
+class AbstractRoutineTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @dataProvider provide_valid_constructor_arguments
+     * @covers Respect\Rest\Routines\AbstractRoutine
+     */
+    public function test_valid_constructor_arguments($argument)
+    {
+        $this->assertInstanceOf(
+            'Respect\Rest\Routines\AbstractRoutine',
+            $result = new Stub($argument)
+        );
+        $this->assertSame(
+            $expected = $argument,
+            $result   = $result->getCallback()
+        );
+    }
+
+    public function provide_valid_constructor_arguments()
+    {
+        return array(
+            array(function() { return 'Hello'; }), // an anonymous function
+            array(array('DateTime', 'createFromFormat')), // a class-method callable pair
+            array(new InstanceWithInvoke), // instance of a callable class
+            array('Stubs\Routines\WhenAlwaysTrue') // a callable class name
+        );
+    }
+
+    /**
+     * @dataProvider provide_invalid_constructor_arguments
+     * @covers Respect\Rest\Routines\AbstractRoutine
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Routine callback must be... guess what... callable!
+     */
+    public function test_invalid_constructor_arguments($argument)
+    {
+        $result = new Stub($argument);
+    }
+
+    public function provide_invalid_constructor_arguments()
+    {
+        return array(
+            array('this_function_name_does_not_exist'),
+            array(new \StdClass), // an instance that is not callable
+        );
+    }
+}

tests/src/Stubs/Routines/AbstractRoutine.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Stubs\Routines;
+
+use Respect\Rest\Routines\AbstractRoutine as RestAbstractRoutine;
+use InvalidArgumentException;
+use ReflectionFunction;
+use ReflectionMethod;
+use Respect\Rest\Routes\AbstractRoute;
+
+/**
+ * Concrete stub class for AbstractRoutines.
+ */
+class AbstractRoutine extends RestAbstractRoutine
+{
+    public function getCallback()
+    {
+        return $this->callback;
+    }
+}