event-publish (#6)

* event-publish

Author: era269

.github/workflows/main.yaml

@@ -17,9 +17,6 @@ jobs:
         phpunit-versions: ['latest']
         phpstan-versions: ['latest']
         include:
-          - php-versions: '7.1'
-            phpunit-versions: '7.5.20'
-            phpstan-versions: ['latest']
           - php-versions: '7.2'
             phpunit-versions: '8.5.15'
             phpstan-versions: ['latest']

composer.json

@@ -6,9 +6,10 @@
     "license": "MIT",
     "prefer-stable": true,
     "require": {
-        "php": "^8.0|^7.1",
+        "php": "^8.0|^7.2",
         "cache/array-adapter": "^1.1",
         "era269/method-map": "^0.1.0",
+        "psr/event-dispatcher": "^1.0",
         "psr/simple-cache": "^1.0"
     },
     "require-dev": {

phpstan.neon

@@ -2,11 +2,3 @@ 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,13 +4,79 @@
 
 namespace Era269\MessageProcessor;
 
-use Era269\MessageProcessor\Traits\CacheAwareTrait;
-use Era269\MessageProcessor\Traits\CanApplyPrivateEventsTrait;
+use Cache\Adapter\PHPArray\ArrayCachePool;
+use Era269\MessageProcessor\MethodMap\ExcludeMethodMapDecorator;
+use Era269\MessageProcessor\MethodMap\OneOrLessMethodMapDecorator;
+use Era269\MessageProcessor\MethodMap\OneOrMoreMethodMapDecorator;
+use Era269\MessageProcessor\Traits\Aware\CacheAwareTrait;
+use Era269\MessageProcessor\Traits\CanApplyEventsTrait;
 use Era269\MessageProcessor\Traits\CanProcessMessage;
+use Era269\MessageProcessor\Traits\CanPublishEventsTrait;
+use Era269\MethodMap\ClassNameMethodMap;
+use Era269\MethodMap\InterfaceMethodMap;
+use Era269\MethodMap\MethodMapCacheDecorator;
+use Era269\MethodMap\MethodMapCollectionDecorator;
+use Era269\MethodMap\MethodMapInterface;
+use Psr\EventDispatcher\EventDispatcherInterface;
+use Psr\SimpleCache\CacheInterface;
+use ReflectionMethod;
 
-abstract class AbstractMessageProcessor implements MessageProcessorInterface
+abstract class AbstractMessageProcessor implements
+    MessageProcessorInterface,
+    CacheAwareInterface,
+    EventDispatcherAwareInterface,
+    ApplyEventMethodMapAwareInterface,
+    ProcessMessageMethodMapAwareInterface
 {
     use CacheAwareTrait;
     use CanProcessMessage;
-    use CanApplyPrivateEventsTrait;
+    use CanApplyEventsTrait;
+    use CanPublishEventsTrait;
+
+    public function __construct(EventDispatcherInterface $eventDispatcher, ?MethodMapInterface $processMessageMethodMap = null, ?MethodMapInterface $applyEventMethodMap = null, ?CacheInterface $cache = null)
+    {
+        $this->setEventDispatcher($eventDispatcher);
+        $this->setCache($cache ?? new ArrayCachePool());
+        $this->setProcessMessageMethodMap(
+            $processMessageMethodMap
+            ?? new MethodMapCacheDecorator(
+                new OneOrMoreMethodMapDecorator(
+                    new OneOrLessMethodMapDecorator(
+                        new ExcludeMethodMapDecorator(
+                            new MethodMapCollectionDecorator(
+                                new ClassNameMethodMap(static::class),
+                                new InterfaceMethodMap(static::class)
+                            ),
+                            ['process']
+                        )
+                    )
+                ),
+                $this->getCache(),
+                static::class
+            )
+        );
+        $this->setApplyEventMethodMap(
+            $applyEventMethodMap
+            ?? new MethodMapCacheDecorator(
+                new OneOrMoreMethodMapDecorator(
+                    new OneOrLessMethodMapDecorator(
+                        new ClassNameMethodMap(
+                            static::class,
+                            ReflectionMethod::IS_PROTECTED
+                        )
+                    )
+                ),
+                $this->getCache(),
+                static::class
+            )
+        );
+    }
+
+    protected function applyAndPublish(object ...$events): void
+    {
+        foreach ($events as $event) {
+            $this->applyThat($event);
+            $this->publishThat($event);
+        }
+    }
 }

src/ApplyEventMethodMapAwareInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor;
+
+use Era269\MethodMap\MethodMapInterface;
+
+interface ApplyEventMethodMapAwareInterface
+{
+    public function setApplyEventMethodMap(MethodMapInterface $applyEventMethodMap): void;
+}

src/CacheAwareInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor;
+
+use Psr\SimpleCache\CacheInterface;
+
+interface CacheAwareInterface
+{
+    public function setCache(CacheInterface $cache): void;
+}

src/EventDispatcherAwareInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor;
+
+use Psr\EventDispatcher\EventDispatcherInterface;
+
+interface EventDispatcherAwareInterface
+{
+    public function setEventDispatcher(EventDispatcherInterface $eventDispatcher): void;
+}

src/Exception/MessageProcessorExceptionInterface.php

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

src/Exception/ParameterIsNotSetLogicException.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Exception;
+
+use LogicException;
+
+final class ParameterIsNotSetLogicException extends LogicException implements MessageProcessorExceptionInterface
+{
+    private const FORMAT_MESSAGE = '%s::%s is not set.';
+    public function __construct(string $className, string $parameterName)
+    {
+        parent::__construct(sprintf(
+            self::FORMAT_MESSAGE,
+            $className,
+            $parameterName
+        ));
+    }
+}

src/Message/EventInterface.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Message;
+
+use Era269\MessageProcessor\MessageInterface;
+
+final class MessageCollection implements MessageCollectionInterface
+{
+    /**
+     * @var MessageInterface[]
+     */
+    private $messages;
+    /**
+     * @var int
+     */
+    private $position = 0;
+
+    public function __construct(
+        MessageInterface ...$messages
+    )
+    {
+        $this->messages = $messages;
+    }
+
+    public function current(): MessageInterface
+    {
+        return $this->messages[$this->position]
+            ?? new NullMessage();
+    }
+
+    public function next(): void
+    {
+        ++$this->position;
+    }
+
+    public function key(): int
+    {
+        return $this->position;
+    }
+
+    public function valid(): bool
+    {
+        return isset($this->messages[$this->position]);
+    }
+
+    public function rewind(): void
+    {
+        $this->position = 0;
+    }
+
+    public function attach(MessageInterface $message): void
+    {
+        $this->messages[] = $message;
+    }
+
+    public function count(): int
+    {
+        return count($this->messages);
+    }
+}

src/Message/MessageCollection.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Message;
+
+use Countable;
+use Era269\MessageProcessor\MessageInterface;
+use Iterator;
+
+/**
+ * @extends Iterator<int, MessageInterface>
+ */
+interface MessageCollectionInterface extends Iterator, Countable, MessageInterface
+{
+    public function current(): MessageInterface;
+
+    public function next(): void;
+
+    public function key(): int;
+
+    public function valid(): bool;
+
+    public function rewind(): void;
+
+    public function attach(MessageInterface $event): void;
+}

src/Message/MessageCollectionInterface.php

@@ -10,5 +10,5 @@ interface MessageProcessorInterface
     /**
      * @throws RuntimeException
      */
-    public function process(MessageInterface $message): MessageInterface;
+    public function process(MessageInterface $message): object;
 }

src/MessageProcessorInterface.php

@@ -31,9 +31,8 @@ public function getMethodNames($object): array
 
     /**
      * @param string[] $methodNames
-     * @param object $message
      *
      * @return string[]
      */
-    abstract protected function getDecorated(array $methodNames, $message): array;
+    abstract protected function getDecorated(array $methodNames, object $message): array;
 }

src/MethodMap/AbstractMethodMapDecorator.php

@@ -25,7 +25,7 @@ public function __construct(MethodMapInterface $methodMap, array $exclude)
     /**
      * @inheritDoc
      */
-    protected function getDecorated(array $methodNames, $message): array
+    protected function getDecorated(array $methodNames, object $message): array
     {
         return array_diff(
             $methodNames,

src/MethodMap/ExcludeMethodMapDecorator.php

@@ -12,7 +12,7 @@ final class OneOrLessMethodMapDecorator extends AbstractMethodMapDecorator imple
     /**
      * @inheritDoc
      */
-    protected function getDecorated(array $methodNames, $message): array
+    protected function getDecorated(array $methodNames, object $message): array
     {
         if (count($methodNames) > 1) {
             throw new LogicException(sprintf(

src/MethodMap/OneOrLessMethodMapDecorator.php

@@ -12,7 +12,7 @@ final class OneOrMoreMethodMapDecorator extends AbstractMethodMapDecorator imple
     /**
      * @inheritDoc
      */
-    protected function getDecorated(array $methodNames, $message): array
+    protected function getDecorated(array $methodNames, object $message): array
     {
         if (empty($methodNames)) {
             throw new LogicException(sprintf(

src/MethodMap/OneOrMoreMethodMapDecorator.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor;
+
+use Era269\MethodMap\MethodMapInterface;
+
+interface ProcessMessageMethodMapAwareInterface
+{
+    public function setProcessMessageMethodMap(MethodMapInterface $processMessageMethodMap): void;
+}

src/ProcessMessageMethodMapAwareInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Era269\MessageProcessor\Traits\Aware;
+
+use Era269\MessageProcessor\Exception\ParameterIsNotSetLogicException;
+use Era269\MethodMap\MethodMapInterface;
+
+trait ApplyEventMethodMapAwareTrait
+{
+    /**
+     * @var MethodMapInterface
+     */
+    private $applyEventMethodMap;
+
+    protected function getApplyEventMethodMap(): MethodMapInterface
+    {
+        if (!isset($this->applyEventMethodMap)) {
+            throw new ParameterIsNotSetLogicException(static::class, 'applyEventMethodMap');
+        }
+
+        return $this->applyEventMethodMap;
+    }
+
+    public function setApplyEventMethodMap(MethodMapInterface $applyEventMethodMap): void
+    {
+        $this->applyEventMethodMap = $applyEventMethodMap;
+    }
+}