Added tactician command bus implementation

Author: italolelis

src/CommandBus/CommandBusInterface.php

@@ -13,11 +13,4 @@ interface CommandBusInterface
      * @param mixed $command A command that will be dispatched
      */
     public function execute($command);
-
-    /**
-     * Subscribes the command handler to this CommandBus
-     * @param string $commandName The command name to map to
-     * @param mixed $handler
-     */
-    public function subscribe($commandName, $handler);
 }

src/CommandBus/EventDispatchingCommandBus.php

@@ -41,12 +41,4 @@ public function execute($command)
             throw $e;
         }
     }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function subscribe($commandName, $handler)
-    {
-        $this->commandBus->subscribe($commandName, $handler);
-    }
 }

src/CommandBus/Exception/CanNotInvokeHandlerException.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace HelloFresh\Engine\CommandBus\Exception;
+
+/**
+ * Thrown when a specific handler object can not be used on a command object.
+ *
+ * The most common reason is the receiving method is missing or incorrectly
+ * named.
+ */
+class CanNotInvokeHandlerException extends \BadMethodCallException
+{
+    /**
+     * @var mixed
+     */
+    private $command;
+
+    /**
+     * @param mixed $command
+     * @param string $reason
+     *
+     * @return static
+     */
+    public static function forCommand($command, $reason)
+    {
+        $type = is_object($command) ? get_class($command) : gettype($command);
+
+        $exception = new static(
+            'Could not invoke handler for command ' . $type .
+            ' for reason: ' . $reason
+        );
+        $exception->command = $command;
+
+        return $exception;
+    }
+
+    /**
+     * Returns the command that could not be invoked
+     *
+     * @return mixed
+     */
+    public function getCommand()
+    {
+        return $this->command;
+    }
+}

src/CommandBus/Exception/MissingHandlerException.php

@@ -0,0 +1,41 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: ilelis
+ * Date: 20/06/16
+ * Time: 14:53
+ */
+
+namespace HelloFresh\Engine\CommandBus\Exception;
+
+/**
+ * No handler could be found for the given command.
+ */
+class MissingHandlerException extends \OutOfBoundsException
+{
+    /**
+     * @var string
+     */
+    private $commandName;
+
+    /**
+     * @param string $commandName
+     *
+     * @return static
+     */
+    public static function forCommand($commandName)
+    {
+        $exception = new static('Missing handler for command ' . $commandName);
+        $exception->commandName = $commandName;
+
+        return $exception;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCommandName()
+    {
+        return $this->commandName;
+    }
+}

src/CommandBus/Handler/HandlerLocatorInterface.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace HelloFresh\Engine\CommandBus\Handler;
+
+use HelloFresh\Engine\CommandBus\Exception\MissingHandlerException;
+
+/**
+ * Service locator for handler objects
+ */
+interface HandlerLocatorInterface
+{
+    /**
+     * Retrieves the handler for a specified command
+     *
+     * @param string $commandName
+     *
+     * @return object
+     *
+     * @throws MissingHandlerException
+     */
+    public function getHandlerForCommand($commandName);
+}

src/CommandBus/Handler/InMemoryLocator.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace HelloFresh\Engine\CommandBus\Handler;
+
+use HelloFresh\Engine\CommandBus\Exception\MissingHandlerException;
+
+class InMemoryLocator implements HandlerLocatorInterface
+{
+    /**
+     * @var object[]
+     */
+    protected $handlers = [];
+
+    /**
+     * @param array $commandClassToHandlerMap
+     */
+    public function __construct(array $commandClassToHandlerMap = [])
+    {
+        $this->addHandlers($commandClassToHandlerMap);
+    }
+
+    /**
+     * Bind a handler instance to receive all commands with a certain class
+     *
+     * @param object $handler Handler to receive class
+     * @param string $commandClassName Command class e.g. "My\TaskAddedCommand"
+     */
+    public function addHandler($handler, $commandClassName)
+    {
+        $this->handlers[$commandClassName] = $handler;
+    }
+
+    /**
+     * Allows you to add multiple handlers at once.
+     * @param array $commandClassToHandlerMap
+     */
+    protected function addHandlers(array $commandClassToHandlerMap)
+    {
+        foreach ($commandClassToHandlerMap as $commandClass => $handler) {
+            $this->addHandler($handler, $commandClass);
+        }
+    }
+
+    /**
+     * Returns the handler bound to the command's class name.
+     *
+     * @param string $commandName
+     *
+     * @return object
+     */
+    public function getHandlerForCommand($commandName)
+    {
+        if (!isset($this->handlers[$commandName])) {
+            throw MissingHandlerException::forCommand($commandName);
+        }
+
+        return $this->handlers[$commandName];
+    }
+}

src/CommandBus/SimpleCommandBus.php

@@ -2,18 +2,12 @@
 
 namespace HelloFresh\Engine\CommandBus;
 
-use Assert\Assertion;
-use Collections\Dictionary;
-use Collections\MapInterface;
 use Collections\Queue;
+use HelloFresh\Engine\CommandBus\Exception\CanNotInvokeHandlerException;
+use HelloFresh\Engine\CommandBus\Handler\HandlerLocatorInterface;
 
 class SimpleCommandBus implements CommandBusInterface
 {
-    /**
-     * @var MapInterface
-     */
-    private $commandHandlers;
-
     /**
      * @var Queue
      */
@@ -25,21 +19,18 @@ class SimpleCommandBus implements CommandBusInterface
     private $isDispatching = false;
 
     /**
-     * SimpleCommandBus constructor.
+     * @var HandlerLocatorInterface
      */
-    public function __construct()
-    {
-        $this->commandHandlers = new Dictionary();
-        $this->queue = new Queue();
-    }
+    private $handlerLocator;
 
     /**
-     * {@inheritDoc}
+     * SimpleCommandBus constructor.
+     * @param HandlerLocatorInterface $handlerLocator
      */
-    public function subscribe($commandName, $handler)
+    public function __construct(HandlerLocatorInterface $handlerLocator)
     {
-        \Assert\that($commandName)->notEmpty()->string();
-        $this->commandHandlers->add($commandName, $handler);
+        $this->queue = new Queue();
+        $this->handlerLocator = $handlerLocator;
     }
 
     /**
@@ -66,11 +57,16 @@ public function execute($command)
      */
     private function processCommand($command)
     {
-        $this->commandHandlers->filterWithKey(function ($commandName, $handler) use ($command) {
-            return $commandName === get_class($command);
-        })->each(function ($handler) use ($command) {
-            Assertion::methodExists('handle', $handler);
-            $handler->handle($command);
-        });
+        $handler = $this->handlerLocator->getHandlerForCommand(get_class($command));
+        $methodName = 'handler';
+
+        if (!is_callable([$handler, $methodName])) {
+            throw CanNotInvokeHandlerException::forCommand(
+                $command,
+                "Method '{$methodName}' does not exist on handler"
+            );
+        }
+
+        $handler->handle($command);
     }
 }

src/CommandBus/TacticianCommandBus.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace HelloFresh\Engine\CommandBus;
+
+use Assert\Assertion;
+use Collections\Dictionary;
+use Collections\MapInterface;
+use Collections\Queue;
+
+class TacticianCommandBus implements CommandBusInterface
+{
+    /**
+     * @var MapInterface
+     */
+    private $commandHandlers;
+
+    /**
+     * @var Queue
+     */
+    private $queue;
+
+    /**
+     * @var bool
+     */
+    private $isDispatching = false;
+
+    /**
+     * SimpleCommandBus constructor.
+     */
+    public function __construct()
+    {
+        $this->commandHandlers = new Dictionary();
+        $this->queue = new Queue();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function subscribe($commandName, $handler)
+    {
+        \Assert\that($commandName)->notEmpty()->string();
+        $this->commandHandlers->add($commandName, $handler);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function execute($command)
+    {
+        $this->queue->enqueue($command);
+
+        if (!$this->isDispatching) {
+            $this->isDispatching = true;
+            try {
+                while (!$this->queue->isEmpty()) {
+                    $this->processCommand($this->queue->pop());
+                }
+            } finally {
+                $this->isDispatching = false;
+            }
+        }
+    }
+
+    /**
+     * @param $command
+     */
+    private function processCommand($command)
+    {
+        $this->commandHandlers->filterWithKey(function ($commandName, $handler) use ($command) {
+            return $commandName === get_class($command);
+        })->each(function ($handler) use ($command) {
+            Assertion::methodExists('handle', $handler);
+            $handler->handle($command);
+        });
+    }
+}