Implement an event dispatcher interface of the PSR-14.

Author: szvsky

packages/Events/src/Event.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the aether/aether.
+ *
+ * Copyright (C) 2024 Dominik Szamburski
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+namespace Aether\Events;
+
+use Psr\EventDispatcher\StoppableEventInterface;
+
+class Event implements StoppableEventInterface
+{
+    protected bool $propagationStopped = false;
+
+    public function isPropagationStopped(): bool
+    {
+        return $this->propagationStopped;
+    }
+
+    /**
+     * Sets the event propagation should be stopped.
+     *
+     * @return void
+     */
+    public function setPropagationStopped(): void
+    {
+        $this->propagationStopped = true;
+    }
+}

packages/Events/src/EventDispatcher.php

@@ -0,0 +1,86 @@
+<?php
+
+/*
+ * This file is part of the aether/aether.
+ *
+ * Copyright (C) 2024 Dominik Szamburski
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+namespace Aether\Events;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use Psr\EventDispatcher\StoppableEventInterface;
+
+#[CoversClass(EventDispatcher::class)]
+class EventDispatcher implements EventDispatcherInterface
+{
+    /** @var callable[][][] */
+    protected array $listeners = [];
+
+    /** @var callable[][] */
+    protected array $sortedListeners = [];
+
+    public function listen(string $eventName, callable $listener, int $priority = 10): void
+    {
+        $this->listeners[$eventName][$priority][] = $listener;
+        unset($this->sortedListeners[$eventName]);
+    }
+
+    public function dispatch(object $event, ?string $eventName = null): object
+    {
+        $eventName ??= $event::class;
+
+        if (($listeners = $this->getListeners($eventName)) !== []) {
+            $this->invokeListeners($listeners, $event, $eventName);
+        }
+
+        return $event;
+    }
+
+    public function getListeners(string $eventName): iterable
+    {
+        if (! isset($this->listeners[$eventName])) {
+            return [];
+        }
+
+        if (! isset($this->sortedListeners[$eventName])) {
+            $this->sortListeners($eventName);
+        }
+
+        return $this->sortedListeners[$eventName];
+    }
+
+    /**
+     * @param callable[] $listeners The event listeners.
+     * @param object $event The event object to pass to the listener.
+     * @param string $eventName The event name.
+     */
+    protected function invokeListeners(iterable $listeners, object $event, string $eventName): void
+    {
+        foreach ($listeners as $listener) {
+            if ($event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
+                break;
+            }
+
+            $listener($event, $eventName, $this);
+        }
+    }
+
+    /**
+     * Sorts the event listeners by priority.
+     */
+    protected function sortListeners(string $eventName): void
+    {
+        \ksort($this->listeners[$eventName]);
+        $this->sortedListeners[$eventName] = [];
+
+        foreach ($this->listeners[$eventName] as &$listeners) {
+            foreach ($listeners as &$listener) {
+                $this->sortedListeners[$eventName][] = $listener;
+            }
+        }
+    }
+}

packages/Events/src/EventDispatcherInterface.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * This file is part of the aether/aether.
+ *
+ * Copyright (C) 2024 Dominik Szamburski
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+namespace Aether\Events;
+
+use Psr\EventDispatcher\EventDispatcherInterface as BaseEventDispatcher;
+
+interface EventDispatcherInterface extends BaseEventDispatcher
+{
+    /**
+     * Registers an event listener with the event dispatcher.
+     *
+     * @param string $eventName The event name.
+     * @param callable $listener A listener for given event.
+     * @param int $priority The higher the priority, the earlier the listener will be triggered.
+     */
+    public function listen(string $eventName, callable $listener, int $priority = 10): void;
+
+    /**
+     * @template T of object
+     *
+     * @param T $event The object to process.
+     * @param null|string $eventName The event name.
+     * @return T The passed $event MUST be returned.
+     */
+    public function dispatch(object $event, ?string $eventName = null): object;
+
+    /**
+     * Gets listeners for given event.
+     *
+     * @param string $eventName The event name.
+     * @return callable[] Returns a sorted array of listeners.
+     */
+    public function getListeners(string $eventName): iterable;
+}

packages/Events/tests/EventDispatcherTest.php

@@ -0,0 +1,67 @@
+<?php
+
+/*
+ * This file is part of the aether/aether.
+ *
+ * Copyright (C) 2024 Dominik Szamburski
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+namespace Aether\Tests\Events;
+
+use Aether\Events\Event;
+use Aether\Events\EventDispatcher;
+use Aether\Events\EventDispatcherInterface;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(EventDispatcher::class)]
+class EventDispatcherTest extends TestCase
+{
+    private EventDispatcherInterface $dispatcher;
+
+    protected function setUp(): void
+    {
+        $this->dispatcher = new EventDispatcher();
+    }
+
+    public function testDispatchesWithoutListeners(): void
+    {
+        $listeners = $this->dispatcher->getListeners('event');
+
+        self::assertEmpty($listeners);
+        self::assertCount(0, $listeners);
+    }
+
+    public function testDispatchShouldInvokeListener(): void
+    {
+        $invoked = false;
+
+        $this->dispatcher->listen('test.event', function () use (&$invoked) {
+            $invoked = true;
+        });
+
+        $this->dispatcher->dispatch(new class () {}, 'test.event');
+
+        self::assertTrue($invoked, 'Listener should be invoked on event dispatch.');
+    }
+
+    public function testDispatchShouldNotInvokeListenerAfterPropagationStopped(): void
+    {
+        $invokedAfterStop = false;
+
+        $this->dispatcher->listen('test.event', function (Event $event) {
+            $event->setPropagationStopped();
+        });
+
+        $this->dispatcher->listen('test.event', function () use (&$invokedAfterStop) {
+            $invokedAfterStop = true;
+        });
+
+        $this->dispatcher->dispatch(new Event(), 'test.event');
+
+        self::assertFalse($invokedAfterStop, 'Listener should not be invoked after propagation is stopped');
+    }
+}