Added custom dependency injection handler in Kernel

Author: WalterWoshid

src/CodeTransformerKernel.php

@@ -2,6 +2,7 @@
 
 namespace Okapi\CodeTransformer;
 
+use Closure;
 use DI\Attribute\Inject;
 use Okapi\CodeTransformer\Core\AutoloadInterceptor;
 use Okapi\CodeTransformer\Core\Cache\CacheStateManager;
@@ -160,7 +161,7 @@ public static function init(): void
     }
 
     /**
-     * Register the dependency injection.
+     * Internal dependency injection.
      *
      * @return void
      */
@@ -199,22 +200,31 @@ protected function configureOptions(): void
     }
 
     /**
-     * Register the services.
+     * Custom dependency injection handler.
      *
-     * @return void
+     * Pass a closure that takes a transformer class name as the argument and
+     * returns a transformer instance.
+     *
+     * @return null|Closure(class-string<Transformer>): Transformer
      */
+    protected function dependencyInjectionHandler(): ?Closure
+    {
+        // Override this method to configure the dependency injection handler
+
+        return null;
+    }
+
     protected function registerServices(): void
     {
-        // Options provider
         $this->options->register();
 
-        // Manage the user-defined transformers
+        $this->transformerManager->registerCustomDependencyInjectionHandler(
+            $this->dependencyInjectionHandler()
+        );
         $this->transformerManager->register();
 
-        // Cache path manager
         $this->cacheStateManager->register();
 
-        // Stream filter -> Source transformer
         $this->streamFilter->register();
     }
 

src/Core/Container/TransformerManager.php

@@ -2,10 +2,12 @@
 /** @noinspection PhpPropertyOnlyWrittenInspection */
 namespace Okapi\CodeTransformer\Core\Container;
 
+use Closure;
 use Error;
 use Exception;
 use Okapi\CodeTransformer\Core\DI;
 use Okapi\CodeTransformer\Core\Exception\Transformer\InvalidTransformerClassException;
+use Okapi\CodeTransformer\Core\Exception\Transformer\InvalidTransformerClassNameException;
 use Okapi\CodeTransformer\Core\Exception\Transformer\TransformerNotFoundException;
 use Okapi\CodeTransformer\Core\ServiceInterface;
 use Okapi\CodeTransformer\Transformer;
@@ -32,6 +34,11 @@ class TransformerManager implements ServiceInterface
      */
     private array $transformerContainers = [];
 
+    /**
+     * @var ?Closure(class-string<Transformer>): Transformer
+     */
+    private ?Closure $dependencyInjectionHandler = null;
+
     // region Pre-Initialization
 
     /**
@@ -54,51 +61,75 @@ public function addTransformers(array $transformers): void
     // region Initialization
 
     /**
-     * Register the transformer container.
-     *
-     * @return void
+     * @param null|(Closure(class-string<Transformer>): Transformer) $dependencyInjectionHandler
      */
+    public function registerCustomDependencyInjectionHandler(
+        ?Closure $dependencyInjectionHandler
+    ): void {
+        $this->dependencyInjectionHandler = $dependencyInjectionHandler;
+    }
+
     public function register(): void
     {
         $this->loadTransformers();
     }
 
+    private function loadTransformers(): void
+    {
+        foreach ($this->transformers as $transformer) {
+            $this->loadTransformer($transformer);
+        }
+    }
+
     /**
-     * Get the transformer instances.
-     *
-     * @return void
+     * @param class-string<Transformer> $transformerClassName
      *
      * @noinspection PhpUnhandledExceptionInspection
      * @noinspection PhpDocMissingThrowsInspection
      */
-    private function loadTransformers(): void
+    private function loadTransformer(mixed $transformerClassName): void
     {
-        foreach ($this->transformers as $transformer) {
-            // Instantiate the transformer
+        // Check if the transformer is already loaded
+        if (array_key_exists($transformerClassName, $this->transformerContainers)) {
+            return;
+        }
+
+        // Validate the transformer
+        if (gettype($transformerClassName) !== 'string') {
+            throw new InvalidTransformerClassNameException;
+        }
+
+        // Instantiate the transformer
+        if ($this->dependencyInjectionHandler) {
+            $transformerInstance = ($this->dependencyInjectionHandler)($transformerClassName);
+
+            if (!($transformerInstance instanceof Transformer)) {
+                throw new InvalidTransformerClassException($transformerClassName);
+            }
+        } else {
             try {
-                $transformerInstance = DI::make($transformer);
+                $transformerInstance = DI::make($transformerClassName);
             } catch (Error|Exception) {
-                throw new TransformerNotFoundException($transformer);
+                throw new TransformerNotFoundException($transformerClassName);
             }
+        }
 
-            // Validate the transformer
-            $isTransformer = $transformerInstance instanceof Transformer;
-            if (!$isTransformer) {
-                throw new InvalidTransformerClassException($transformer);
-            }
-            assert($transformerInstance instanceof Transformer);
+        // Validate the transformer
+        $isTransformer = $transformerInstance instanceof Transformer;
+        if (!$isTransformer) {
+            throw new InvalidTransformerClassException($transformerClassName);
+        }
 
-            // Create transformer container
-            $transformerContainer = DI::make(TransformerContainer::class, [
-                'transformerInstance' => $transformerInstance,
-            ]);
+        // Create transformer container
+        $transformerContainer = DI::make(TransformerContainer::class, [
+            'transformerInstance' => $transformerInstance,
+        ]);
 
-            // Create a reflection of the transformer
-            $transformerRefClass = new BaseReflectionClass($transformerInstance);
+        // Create a reflection of the transformer
+        $transformerRefClass = new BaseReflectionClass($transformerInstance);
 
-            $filePath = $transformerRefClass->getFileName();
-            $this->transformerContainers[$filePath] = $transformerContainer;
-        }
+        $filePath = $transformerRefClass->getFileName();
+        $this->transformerContainers[$filePath] = $transformerContainer;
     }
 
     // endregion

src/Core/Exception/Transformer/InvalidTransformerClassNameException.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Okapi\CodeTransformer\Core\Exception\Transformer;
+
+use Okapi\CodeTransformer\Core\Exception\TransformerException;
+
+class InvalidTransformerClassNameException extends TransformerException
+{
+    public function __construct()
+    {
+        parent::__construct(
+            'Transformer class name in Kernel must be a string.',
+        );
+    }
+}