Override callback resolver

src/Application.php

@@ -48,16 +48,28 @@ public function __construct(ContainerBuilder $containerBuilder = null, array $va
 
         parent::__construct($values);
 
+        $this['phpdi.callable_resolver'] = $this->share(function () {
+            return new CallableResolver($this->containerInteropProxy);
+        });
+
         // Override the controller resolver with ours
         $this['resolver'] = $this->share(function () {
             return new ControllerResolver(
-                new CallableResolver($this->containerInteropProxy),
+                $this['phpdi.callable_resolver'],
                 new ResolverChain([
                     new AssociativeArrayResolver,
                     new TypeHintContainerResolver($this->containerInteropProxy),
                 ])
             );
         });
+
+        // Override the callback resolver with ours
+        $this['callback_resolver'] = $this->share(function () {
+            return new CallbackResolver(
+                $this,
+                $this['phpdi.callable_resolver']
+            );
+        });
     }
 
     public function offsetGet($id)

src/CallbackResolver.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace DI\Bridge\Silex;
+
+use Invoker\CallableResolver;
+use Invoker\Exception\NotCallableException;
+
+/**
+ * This alternative resolver uses the generic Invoker to support PHP-DI's extended callable syntax
+ */
+class CallbackResolver extends \Silex\CallbackResolver
+{
+    /**
+     * @var CallableResolver
+     */
+    private $resolver;
+
+    public function __construct(\Pimple $app, CallableResolver $resolver)
+    {
+        $this->resolver = $resolver;
+        parent::__construct($app);
+    }
+
+    /**
+     * @param string $name
+     * @return array|callable
+     */
+    public function convertCallback($name)
+    {
+        // original pattern
+        if ($this->isValid($name)) {
+            return parent::convertCallback($name);
+        }
+
+        // try to resolve callback from container
+        try {
+            return $this->resolver->resolve($name);
+        } catch (NotCallableException $e) {
+            throw new \InvalidArgumentException(sprintf('Service "%s" does not exist.', $name));
+        }
+    }
+
+    /**
+     * @param string|callable $name
+     * @return callable
+     */
+    public function resolveCallback($name)
+    {
+        // return immediately if $name is callable
+        if (is_callable($name)) {
+            return $name;
+        }
+
+        return $this->convertCallback($name);
+    }
+}

tests/ApplicationTest.php

@@ -53,4 +53,14 @@ public function the_controller_resolver_should_be_registered_as_a_service()
         $this->assertInstanceOf('Closure', $app->raw('resolver'));
         $this->assertInstanceOf('DI\Bridge\Silex\Controller\ControllerResolver', $app['resolver']);
     }
+
+    /**
+     * @test
+     */
+    public function the_callback_resolver_should_be_registered_as_a_service()
+    {
+        $app = new Application();
+
+        $this->assertInstanceOf('DI\Bridge\Silex\CallbackResolver', $app['callback_resolver']);
+    }
 }

tests/CallbackResolverTest.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace DI\Bridge\Silex\Test;
+
+use DI\Bridge\Silex\Application;
+use DI\Bridge\Silex\Test\Fixture\InvokableController;
+
+class CallbackResolverTest extends BaseTestCase
+{
+    /**
+     * @test
+     */
+    public function resolver_must_be_able_to_resolve_original_callback_format()
+    {
+        $app = new Application();
+        $app['controller'] = function () {
+            return new InvokableController();
+        };
+
+        $callable = $app['callback_resolver']->resolveCallback('controller:__invoke');
+
+        $this->assertEquals('Hello world', $callable());
+    }
+
+    /**
+     * @test
+     */
+    public function resolver_must_be_able_to_resolve_custom_callback_format()
+    {
+        $app = new Application();
+        $app['controller'] = function () {
+            return new InvokableController();
+        };
+
+        $callable = $app['callback_resolver']->resolveCallback('controller');
+
+        $this->assertEquals('Hello world', $callable());
+    }
+
+    /**
+     * @test
+     */
+    public function resolver_must_be_able_to_resolve_callable_callback()
+    {
+        $app = new Application();
+
+        $callable = $app['callback_resolver']->resolveCallback(function () {
+            return 'Hello world';
+        });
+
+        $this->assertEquals('Hello world', $callable());
+    }
+
+    /**
+     * @test
+     */
+    public function resolver_must_throw_exception_when_callback_not_found_in_container()
+    {
+        $app = new Application();
+
+        $this->setExpectedException('\InvalidArgumentException');
+        $app['callback_resolver']->resolveCallback('some.service');
+    }
+}

tests/Fixture/HelloController.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace DI\Bridge\Silex\Test\Fixture;
+
+class HelloController
+{
+    public function __invoke(\ArrayObject $user)
+    {
+        return $user['name'];
+    }
+}

tests/Fixture/InvokableConverter.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace DI\Bridge\Silex\Test\Fixture;
+
+class InvokableConverter
+{
+    public function __invoke($user)
+    {
+        return new \ArrayObject(['name' => $user]);
+    }
+}

tests/Fixture/InvokableErrorListener.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace DI\Bridge\Silex\Test\Fixture;
+
+use Symfony\Component\HttpFoundation\Response;
+
+class InvokableErrorListener
+{
+    public function __invoke(\Exception $e, $code)
+    {
+        return new Response('Sad panda :(');
+    }
+}

tests/Fixture/InvokableMiddleware.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace DI\Bridge\Silex\Test\Fixture;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+class InvokableMiddleware
+{
+    public function __invoke(Request $request)
+    {
+        return new Response('Hello from middleware');
+    }
+}

tests/Fixture/InvokableViewListener.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace DI\Bridge\Silex\Test\Fixture;
+
+class InvokableViewListener
+{
+    public function __invoke($controllerResult)
+    {
+        return $controllerResult . ' from mars';
+    }
+}

tests/FunctionalTest.php

@@ -188,4 +188,60 @@ public function should_pass_request_object_based_on_type_hint()
         $response = $app->handle(Request::create('/?name=john'));
         $this->assertEquals('Hello john', $response->getContent());
     }
+
+    /**
+     * @test
+     */
+    public function should_be_able_to_convert_request()
+    {
+        $app = $this->createApplication();
+
+        $app->get('/{user}', 'DI\Bridge\Silex\Test\Fixture\HelloController')
+            ->convert('user', 'DI\Bridge\Silex\Test\Fixture\InvokableConverter');
+
+        $response = $app->handle(Request::create('/PHPDI'));
+        $this->assertEquals('PHPDI', $response->getContent());
+    }
+
+    /**
+     * @test
+     */
+    public function should_be_able_to_use_invokable_middleware()
+    {
+        $app = $this->createApplication();
+
+        $app->get('/', 'DI\Bridge\Silex\Test\Fixture\InvokableController')
+            ->before('DI\Bridge\Silex\Test\Fixture\InvokableMiddleware');
+
+        $response = $app->handle(Request::create('/'));
+        $this->assertEquals('Hello from middleware', $response->getContent());
+    }
+
+    /**
+     * @test
+     */
+    public function should_be_able_to_use_invokable_error_listener()
+    {
+        $app = $this->createApplication();
+
+        $app->error('DI\Bridge\Silex\Test\Fixture\InvokableErrorListener');
+
+        $response = $app->handle(Request::create('/'));
+        $this->assertEquals('Sad panda :(', $response->getContent());
+    }
+
+    /**
+     * @test
+     */
+    public function should_be_able_to_use_view_listener()
+    {
+        $app = $this->createApplication();
+
+        $app->get('/', 'DI\Bridge\Silex\Test\Fixture\InvokableController');
+
+        $app->view('DI\Bridge\Silex\Test\Fixture\InvokableViewListener');
+
+        $response = $app->handle(Request::create('/'));
+        $this->assertEquals('Hello world from mars', $response->getContent());
+    }
 }