Remove some interfaces, make handlers and subscribers a callable

UPGRADE-2.x-to-3.0.md

@@ -0,0 +1,76 @@
+# How to upgrade from MessageBus `2.x` to `3.0`
+
+## The `Message`, `Command` and `Event` have been removed
+
+A message (command, event, etc.) can be any object now, so just remove any type-hint or replace type-hints by more
+specific ones.
+
+The `Message` type-hint has been removed from the following methods:
+
+- `SimpleBus\Message\Bus\MessageBus::handle`
+- `SimpleBus\Message\Bus\Middleware\MessageBusMiddleware::handle`
+- `SimpleBus\Message\Handler\Resolver\MessageHandlerResolver::resolve`
+- `SimpleBus\Message\Subscriber\Resolver\MessageSubscribersResolver::resolve`
+- `SimpleBus\Message\Name\MessageNameResolver::resolve`
+
+## The `MessageHandler` interface has been removed
+
+Message handlers can be any callable now, so just remove the ` implements MessageHandler` from your message handler
+class definitions.
+
+## The `MessageSubscriber` interface has been removed
+
+Message subscribers can be any callable now, so just remove the ` implements MessageSubscriber` from your message
+handler class definitions.
+
+## `MessageHandlerMap` and `MessageSubscriberCollection` have been removed
+
+Instead, handlers and subscribers can now be any callable you like. Also, they are assumed to be always lazy-loading
+(because they should never all be instantiated at the same time). So instead of:
+
+```php
+use SimpleBus\Message\Handler\Map\LazyLoadingMessageHandlerMap;
+
+$serviceLocator = ...;
+
+$commandHandlersByCommandName = [
+    'Fully\Qualified\Class\Name\Of\Command' => 'command_handler_service_id'
+];
+
+$commandHandlerMap = new LazyLoadingMessageHandlerMap(
+    $commandHandlersByCommandName,
+    $serviceLocator
+);
+
+$commandBus->appendMiddleware(
+    new DelegatesToMessageHandlerMiddleware(
+        $commandHandlerResolver
+    )
+);
+```
+
+you should now define a callable map:
+
+```php
+use SimpleBus\Message\CallableResolver\CallableMap;
+use SimpleBus\Message\CallableResolver\ServiceLocatorAwareCallableResolver;
+
+$serviceLocator = ...;
+
+$commandHandlersByCommandName = [
+    'Fully\Qualified\Class\Name\Of\Command' => ['command_handler_service_id', 'handle']
+];
+
+$commandHandlerMap = new CallableMap(
+    $commandHandlersByCommandName,
+    new ServiceLocatorAwareCallableResolver($serviceLocator)
+);
+
+$commandBus->appendMiddleware(
+    new DelegatesToMessageHandlerMiddleware(
+        $commandHandlerResolver
+    )
+);
+```
+
+This is the same for

src/CallableResolver/CallableCollection.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace SimpleBus\Message\CallableResolver;
+
+use Assert\Assertion;
+
+class CallableCollection
+{
+    /**
+     * @var array
+     */
+    private $callablesByName;
+
+    /**
+     * @var CallableResolver
+     */
+    private $callableResolver;
+
+    public function __construct(
+        array $callablesByName,
+        CallableResolver $callableResolver
+    ) {
+        Assertion::allIsArray($callablesByName, 'You need to provide arrays of callables, indexed by name');
+
+        $this->callablesByName = $callablesByName;
+        $this->callableResolver = $callableResolver;
+    }
+
+    /**
+     * @param string $name
+     * @return callable[]
+     */
+    public function filter($name)
+    {
+        if (!array_key_exists($name, $this->callablesByName)) {
+            return [];
+        }
+
+        $callables = $this->callablesByName[$name];
+
+        return array_map([$this->callableResolver, 'resolve'], $callables);
+    }
+}

src/CallableResolver/CallableMap.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace SimpleBus\Message\CallableResolver;
+
+use SimpleBus\Message\CallableResolver\Exception\UndefinedCallable;
+
+class CallableMap
+{
+    /**
+     * @var array
+     */
+    private $callablesByName;
+
+    /**
+     * @var CallableResolver
+     */
+    private $callableResolver;
+
+    public function __construct(
+        array $callablesByName,
+        CallableResolver $callableResolver
+    ) {
+        $this->callablesByName = $callablesByName;
+        $this->callableResolver = $callableResolver;
+    }
+
+    /**
+     * @param string $name
+     * @return callable
+     */
+    public function get($name)
+    {
+        if (!array_key_exists($name, $this->callablesByName)) {
+            throw new UndefinedCallable(
+                sprintf(
+                    'Could not find a callable for name "%s"',
+                    $name
+                )
+            );
+        }
+
+        $callable = $this->callablesByName[$name];
+
+        return $this->callableResolver->resolve($callable);
+    }
+}

src/CallableResolver/CallableResolver.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace SimpleBus\Message\CallableResolver;
+
+use SimpleBus\Message\CallableResolver\Exception\CouldNotResolveCallable;
+
+interface CallableResolver
+{
+    /**
+     * @param $maybeCallable
+     * @throws CouldNotResolveCallable
+     * @return callable
+     */
+    public function resolve($maybeCallable);
+}

src/CallableResolver/Exception/CouldNotResolveCallable.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace SimpleBus\Message\CallableResolver\Exception;
+
+class CouldNotResolveCallable extends \LogicException
+{
+}

src/CallableResolver/Exception/UndefinedCallable.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace SimpleBus\Message\CallableResolver\Exception;
+
+class UndefinedCallable extends \LogicException
+{
+}

src/CallableResolver/ServiceLocatorAwareCallableResolver.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace SimpleBus\Message\CallableResolver;
+
+use SimpleBus\Message\CallableResolver\Exception\CouldNotResolveCallable;
+
+class ServiceLocatorAwareCallableResolver implements CallableResolver
+{
+    /**
+     * @var callable
+     */
+    private $serviceLocator;
+
+    public function __construct(callable $serviceLocator)
+    {
+        $this->serviceLocator = $serviceLocator;
+    }
+
+    /**
+     * @param $maybeCallable
+     * @return callable
+     */
+    public function resolve($maybeCallable)
+    {
+        if (is_callable($maybeCallable)) {
+            return $maybeCallable;
+        }
+
+        if (is_string($maybeCallable)) {
+            // a string can be converted to an object, which may then be a callable
+            return $this->resolve($this->loadService($maybeCallable));
+        }
+
+        if (is_array($maybeCallable) && count($maybeCallable) === 2) {
+            list($serviceId, $method) = $maybeCallable;
+            if (is_string($serviceId)) {
+                return $this->resolve([$this->loadService($serviceId), $method]);
+            }
+        }
+
+        throw new CouldNotResolveCallable();
+    }
+
+    private function loadService($serviceId)
+    {
+        return call_user_func($this->serviceLocator, $serviceId);
+    }
+}

src/Handler/DelegatesToMessageHandlerMiddleware.php

@@ -8,6 +8,9 @@
 
 class DelegatesToMessageHandlerMiddleware implements MessageBusMiddleware
 {
+    /**
+     * @var MessageHandlerResolver
+     */
     private $messageHandlerResolver;
 
     public function __construct(MessageHandlerResolver $messageHandlerResolver)
@@ -16,13 +19,14 @@ public function __construct(MessageHandlerResolver $messageHandlerResolver)
     }
 
     /**
-     * Handles the message by resolving the correct MessageHandler and calling it.
+     * Handles the message by resolving the correct message handler and calling it.
      *
      * {@inheritdoc}
      */
     public function handle($message, callable $next)
     {
-        $this->messageHandlerResolver->resolve($message)->handle($message);
+        $handler = $this->messageHandlerResolver->resolve($message);
+        call_user_func($handler, $message);
 
         $next($message);
     }

src/Handler/Resolver/MessageHandlerResolver.php

@@ -2,15 +2,13 @@
 
 namespace SimpleBus\Message\Handler\Resolver;
 
-use SimpleBus\Message\Handler\MessageHandler;
-
 interface MessageHandlerResolver
 {
     /**
-     * Resolve the MessageHandler for the given Message.
+     * Resolve the message handler callable for the given message.
      *
      * @param object $message
-     * @return MessageHandler
+     * @return callable
      */
     public function resolve($message);
 }