feat: implement custom event dispatcher and listener system (#13)

Reviewed-on: #13
Co-authored-by: Ron Rise <ron@siteworxpro.com>
Co-committed-by: Ron Rise <ron@siteworxpro.com>

src/Events/Dispatcher.php

@@ -0,0 +1,205 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\App\Events;
+
+use Illuminate\Contracts\Events\Dispatcher as DispatcherContract;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Collection;
+use Siteworxpro\App\Annotations\Events\ListensFor;
+
+/**
+ * Class Dispatcher
+ *
+ * A custom event dispatcher that automatically registers event listeners
+ * based on the ListensFor attribute.
+ *
+ * @package Siteworxpro\App\Events
+ */
+class Dispatcher implements DispatcherContract, Arrayable
+{
+    /**
+     * @var array $listeners Registered event listeners
+     */
+    private array $listeners = [];
+
+    /**
+     * @var Collection $pushed Pushed events collection
+     */
+    private Collection $pushed;
+
+    /**
+     * @var string LISTENERS_NAMESPACE The namespace where listeners are located
+     */
+    private const string LISTENERS_NAMESPACE = 'Siteworxpro\\App\\Events\\Listeners\\';
+
+    public function __construct()
+    {
+        $this->pushed = new Collection();
+        $this->registerListeners();
+    }
+
+    /**
+     * Register event listeners based on the ListensFor attribute.
+     *
+     * @return void
+     */
+    private function registerListeners(): void
+    {
+        // traverse the Listeners directory and register all listeners
+        $listenersPath = __DIR__ . '/Listeners';
+        $iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($listenersPath));
+
+        foreach ($iterator as $file) {
+            if ($file->isFile() && $file->getExtension() === 'php') {
+                $relativePath = str_replace($listenersPath . '/', '', $file->getPathname());
+                $className = self::LISTENERS_NAMESPACE . str_replace(['/', '.php'], ['\\', ''], $relativePath);
+                if (class_exists($className)) {
+                    $reflectionClass = new \ReflectionClass($className);
+                    $attributes = $reflectionClass->getAttributes(ListensFor::class);
+                    foreach ($attributes as $attribute) {
+                        $instance = $attribute->newInstance();
+                        $eventClass = $instance->eventClass;
+                        $this->listen($eventClass, new $className());
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Register a listener for the given events.
+     *
+     * @param $events
+     * @param $listener
+     * @return void
+     */
+    public function listen($events, $listener = null): void
+    {
+        $this->listeners[$events][] = $listener;
+    }
+
+    /**
+     * Check if there are listeners for the given event.
+     *
+     * @param $eventName
+     * @return bool
+     */
+    public function hasListeners($eventName): bool
+    {
+        return isset($this->listeners[$eventName]) && !empty($this->listeners[$eventName]);
+    }
+
+    /**
+     * Subscribe a subscriber to the dispatcher.
+     *
+     * @param Arrayable $subscriber
+     * @return void
+     */
+    public function subscribe($subscriber): void
+    {
+        $this->listeners = array_merge($this->listeners, (array) $subscriber);
+    }
+
+    /**
+     * Dispatch an event and halt on the first non-null response.
+     *
+     * @param $event
+     * @param array $payload
+     * @return array|null
+     */
+    public function until($event, $payload = []): array|null
+    {
+        return $this->dispatch($event, $payload, true);
+    }
+
+    /**
+     * Dispatch an event to its listeners.
+     *
+     * @param $event
+     * @param array $payload
+     * @param bool $halt
+     * @return array|null
+     */
+    public function dispatch($event, $payload = [], $halt = false): array|null
+    {
+        if (is_object($event)) {
+            $eventClass = get_class($event);
+        } else {
+            $eventClass = $event;
+        }
+
+        $listeners = $this->listeners[$eventClass] ?? null;
+
+        if ($listeners === null) {
+            return null;
+        }
+
+        $responses = [];
+
+        foreach ($listeners as $listener) {
+            $response = $listener($event, $payload);
+            $responses[] = $response;
+
+            if ($halt && $response !== null) {
+                return $response;
+            }
+        }
+
+        return $responses;
+    }
+
+    /**
+     * Push an event to be dispatched later.
+     *
+     * @param $event
+     * @param array $payload
+     * @return void
+     */
+    public function push($event, $payload = []): void
+    {
+        $this->pushed->put($event, $payload);
+    }
+
+    /**
+     * Flush a pushed event, dispatching it if it exists.
+     *
+     * @param $event
+     * @return void
+     */
+    public function flush($event): void
+    {
+        if ($this->pushed->has($event)) {
+            $payload = $this->pushed->get($event);
+            $this->dispatch($event, $payload);
+            $this->pushed->forget([$event]);
+        }
+    }
+
+    /**
+     * Forget a pushed event without dispatching it.
+     *
+     * @param $event
+     * @return void
+     */
+    public function forget($event): void
+    {
+        $this->pushed->forget([$event]);
+    }
+
+    /**
+     * Forget all pushed events.
+     *
+     * @return void
+     */
+    public function forgetPushed(): void
+    {
+        $this->pushed = new Collection();
+    }
+
+    public function toArray(): array
+    {
+        return $this->listeners;
+    }
+}