Event apply (#5)

* event-apply

Author: era269

phpstan.neon

@@ -2,3 +2,11 @@ parameters:
     level: 8
     paths:
         - src
+    ignoreErrors:
+        -
+            message: '/Method Era269\\MessageProcessor\\AbstractMessageProcessor::getMethodName\(\) should return string but returns string\|false./'
+            path: ./src/Traits/CanGetMethodNameByMessageTrait.php
+        -
+            message: '/Method Era269\\MessageProcessor\\AbstractMessageProcessor::getApplyEventMethodName\(\) should return string but returns string\|false./'
+            path: ./src/Traits/CanGetMethodNameByEventTrait.php
+

src/AbstractMessageProcessor.php

@@ -4,22 +4,13 @@
 
 namespace Era269\MessageProcessor;
 
-use Era269\MessageProcessor\Message\NullMessage;
-use Era269\MessageProcessor\Traits\CanGetMethodNameByMessageTrait;
-use RuntimeException;
+use Era269\MessageProcessor\Traits\CacheAwareTrait;
+use Era269\MessageProcessor\Traits\CanApplyPrivateEventsTrait;
+use Era269\MessageProcessor\Traits\CanProcessMessage;
 
 abstract class AbstractMessageProcessor implements MessageProcessorInterface
 {
-    use CanGetMethodNameByMessageTrait;
-
-    /**
-     * @throws RuntimeException
-     */
-    final public function process(MessageInterface $message): MessageInterface
-    {
-        $methodName = $this->getMethodName($message);
-
-        return $this->$methodName($message)
-            ?? new NullMessage();
-    }
+    use CacheAwareTrait;
+    use CanProcessMessage;
+    use CanApplyPrivateEventsTrait;
 }

src/Message/EventInterface.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Message;
+
+use Era269\MessageProcessor\MessageInterface;
+
+interface EventInterface extends MessageInterface
+{
+}

src/MethodMap/AbstractMethodMapDecorator.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\MethodMap;
+
+use Era269\MethodMap\MethodMapInterface;
+
+abstract class AbstractMethodMapDecorator implements MethodMapInterface
+{
+    /**
+     * @var MethodMapInterface
+     */
+    private $methodMap;
+
+    public function __construct(MethodMapInterface $methodMap)
+    {
+        $this->methodMap = $methodMap;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getMethodNames($object): array
+    {
+        return $this->getDecorated(
+            $this->methodMap->getMethodNames($object),
+            $object
+        );
+    }
+
+    /**
+     * @param string[] $methodNames
+     * @param object $message
+     *
+     * @return string[]
+     */
+    abstract protected function getDecorated(array $methodNames, $message): array;
+}

src/MethodMap/ExcludeMethodMapDecorator.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\MethodMap;
+
+use Era269\MethodMap\MethodMapInterface;
+
+final class ExcludeMethodMapDecorator extends AbstractMethodMapDecorator implements MethodMapInterface
+{
+    /**
+     * @var string[]
+     */
+    private $exclude;
+
+    /**
+     * @param string[] $exclude
+     */
+    public function __construct(MethodMapInterface $methodMap, array $exclude)
+    {
+        parent::__construct($methodMap);
+        $this->exclude = $exclude;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected function getDecorated(array $methodNames, $message): array
+    {
+        return array_diff(
+            $methodNames,
+            $this->exclude
+        );
+    }
+}

src/MethodMap/OneOrLessMethodMapDecorator.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\MethodMap;
+
+use Era269\MethodMap\MethodMapInterface;
+use LogicException;
+
+final class OneOrLessMethodMapDecorator extends AbstractMethodMapDecorator implements MethodMapInterface
+{
+    /**
+     * @inheritDoc
+     */
+    protected function getDecorated(array $methodNames, $message): array
+    {
+        if (count($methodNames) > 1) {
+            throw new LogicException(sprintf(
+                'Controversial internal method call. More than one method [%s] can process "%s"',
+                implode(',', $methodNames),
+                get_class($message)
+            ));
+        }
+        return $methodNames;
+    }
+}

src/MethodMap/OneOrMoreMethodMapDecorator.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\MethodMap;
+
+use Era269\MethodMap\MethodMapInterface;
+use LogicException;
+
+final class OneOrMoreMethodMapDecorator extends AbstractMethodMapDecorator implements MethodMapInterface
+{
+    /**
+     * @inheritDoc
+     */
+    protected function getDecorated(array $methodNames, $message): array
+    {
+        if (empty($methodNames)) {
+            throw new LogicException(sprintf(
+                'Incorrect internal method call: object doesn\'t know how to process the message "%s"',
+                get_class($message)
+            ));
+        }
+        return $methodNames;
+    }
+}

src/Traits/CacheAwareTrait.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Traits;
+
+use Cache\Adapter\PHPArray\ArrayCachePool;
+use Psr\SimpleCache\CacheInterface;
+
+trait CacheAwareTrait
+{
+    /**
+     * @var CacheInterface
+     */
+    private $cache;
+
+    public function setCache(CacheInterface $cache): void
+    {
+        $this->cache = $cache;
+    }
+
+    private function getCache(): CacheInterface
+    {
+        if (!isset($this->cache)) {
+            $this->cache = new ArrayCachePool();
+        }
+        return $this->cache;
+    }
+}

src/Traits/CanApplyPrivateEventsTrait.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Traits;
+
+use Era269\MessageProcessor\Message\EventInterface;
+
+trait CanApplyPrivateEventsTrait
+{
+    use CanGetMethodNameByEventTrait;
+
+    protected function apply(EventInterface ...$events): void
+    {
+        foreach ($events as $event) {
+            $this->applyThat($event);
+        }
+    }
+
+    private function applyThat(EventInterface $event): void
+    {
+        $methodName = $this->getApplyEventMethodName($event);
+        $this->{$methodName}($event);
+    }
+}

src/Traits/CanGetMethodNameByEventTrait.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Traits;
+
+use Era269\MessageProcessor\Message\EventInterface;
+use Era269\MessageProcessor\MethodMap\OneOrLessMethodMapDecorator;
+use Era269\MessageProcessor\MethodMap\OneOrMoreMethodMapDecorator;
+use Era269\MethodMap\ClassNameMethodMap;
+use Era269\MethodMap\MethodMapCacheDecorator;
+use Era269\MethodMap\MethodMapInterface;
+use Psr\SimpleCache\CacheInterface;
+use ReflectionMethod;
+
+trait CanGetMethodNameByEventTrait
+{
+    /**
+     * @var MethodMapInterface
+     */
+    private $applyEventMap;
+
+    /**
+     * @param ClassNameMethodMap $applyEventMap
+     */
+    public function setApplyEventMap(MethodMapInterface $applyEventMap): void
+    {
+        $this->applyEventMap = $this->getDecoratedByExactlyOneMethodMap($applyEventMap);
+    }
+
+    private function getApplyEventMethodName(EventInterface $event): string
+    {
+        return current(
+            $this->getApplyEventMap()->getMethodNames($event)
+        );
+    }
+
+    private function getApplyEventMap(): MethodMapInterface
+    {
+        if (!isset($this->applyEventMap)) {
+            $this->applyEventMap =
+                new MethodMapCacheDecorator(
+                    $this->getDecoratedByExactlyOneMethodMap(
+                        new ClassNameMethodMap(
+                            static::class,
+                            ReflectionMethod::IS_PROTECTED
+                        )
+                    ),
+                    $this->getCache(),
+                    static::class
+                );
+        }
+
+        return $this->applyEventMap;
+    }
+
+    private function getDecoratedByExactlyOneMethodMap(MethodMapInterface $methodMap): MethodMapInterface
+    {
+        return new OneOrMoreMethodMapDecorator(
+            new OneOrLessMethodMapDecorator(
+                $methodMap
+            )
+        );
+    }
+
+    abstract protected function getCache(): CacheInterface;
+}