Added custom dependency injection handler in Kernel

composer.json

@@ -1,7 +1,7 @@
 {
     "name": "okapi/code-transformer",
     "description": "PHP Code Transformer is a PHP library that allows you to modify and transform the source code of a loaded PHP class.",
-    "version": "1.3.3",
+    "version": "1.3.4",
     "type": "library",
     "homepage": "https://github.com/okapi-web/php-code-transformer",
     "license": "MIT",

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/AutoloadInterceptor/ClassLoader.php

@@ -86,6 +86,7 @@ public function loadClass($namespacedClass): bool
      * @return false|string
      *
      * @noinspection PhpParameterNameChangedDuringInheritanceInspection
+     * @noinspection PhpStatementHasEmptyBodyInspection
      */
     public function findFile($namespacedClass): false|string
     {

src/Core/Cache/CacheStateManager.php

@@ -89,8 +89,14 @@ public function register(): void
      */
     private function initializeCacheDirectory(): void
     {
+        $cacheDir = $this->options->getCacheDir();
+
+        if (file_exists($cacheDir)) {
+            return;
+        }
+
         Filesystem::mkdir(
-            $this->options->getCacheDir(),
+            $cacheDir,
             $this->options->getCacheFileMode(),
             recursive: true,
         );

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,73 @@ 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)) {
+            // @codeCoverageIgnoreStart
+            return;
+            // @codeCoverageIgnoreEnd
+        }
+
+        // Validate the transformer
+        if (gettype($transformerClassName) !== 'string') {
+            throw new InvalidTransformerClassNameException;
+        }
+
+        // Instantiate the transformer
+        if ($this->dependencyInjectionHandler) {
+            $transformerInstance = ($this->dependencyInjectionHandler)($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.',
+        );
+    }
+}

tests/Functional/ReplaceStringInClassTest.php → tests/Functional/Cache/CachedFileAndDestructor/CachedFileAndDestructorTest.php

@@ -1,27 +1,26 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor;
 
 use Okapi\CodeTransformer\Core\Cache\CacheStateManager;
 use Okapi\CodeTransformer\Core\DI;
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\StringClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
-use Okapi\CodeTransformer\Tests\Stubs\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer\StringTransformer;
 use Okapi\CodeTransformer\Tests\Util;
 use Okapi\Filesystem\Filesystem;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
 use PHPUnit\Framework\TestCase;
 
 #[RunTestsInSeparateProcesses]
-class ReplaceStringInClassTest extends TestCase
+class CachedFileAndDestructorTest extends TestCase
 {
     use ClassLoaderMockTrait;
 
     public function testReplaceStringInClass(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
         $class = StringClass::class;
         $this->assertWillBeTransformed($class);
@@ -32,7 +31,7 @@ public function testReplaceStringInClass(): void
             $stringClass->test(),
         );
 
-        $file    = Util::CLASSES_TO_TRANSFORM_DIR . '/StringClass.php';
+        $file    = Util::getFilePath(StringClass::class);
         $content = Filesystem::readFile($file);
 
         $this->assertEquals(
@@ -43,7 +42,7 @@ public function testReplaceStringInClass(): void
 
     public function testCachedReplaceStringClass(): void
     {
-        ApplicationKernel::init();
+        Kernel::init();
 
         $class = StringClass::class;
         $this->assertTransformerLoadedFromCache($class);
@@ -57,7 +56,7 @@ public function testCachedReplaceStringClass(): void
 
     public function testCachedFile(): void
     {
-        $cachedFilePath = Util::CACHED_CLASSES_TO_TRANSFORM_DIR . '/StringClass.php';
+        $cachedFilePath = Util::getTransformedFilePath(StringClass::class);
 
         $this->assertFileExists($cachedFilePath);
         $file = Filesystem::readFile($cachedFilePath);
@@ -76,7 +75,7 @@ public function testCachedFile(): void
     public function testDestructor(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
         $class = StringClass::class;
         $stringClass = new $class();
@@ -89,7 +88,7 @@ public function testDestructor(): void
 
         $file = require Util::CACHE_STATES_FILE;
 
-        $key = 'CODE_TRANSFORMER_APP_DIR\tests\Stubs\ClassesToTransform\StringClass.php';
+        $key = 'CODE_TRANSFORMER_APP_DIR\tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass.php';
         $key = str_replace('\\', DIRECTORY_SEPARATOR, $key);
         $this->assertArrayHasKey($key, $file);
     }

tests/Functional/Cache/CachedFileAndDestructor/Kernel.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor;
+
+use Okapi\CodeTransformer\CodeTransformerKernel;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer\StringTransformer;
+use Okapi\CodeTransformer\Tests\Util;
+
+class Kernel extends CodeTransformerKernel
+{
+    protected ?string $cacheDir = Util::CACHE_DIR;
+
+    protected array $transformers = [
+        StringTransformer::class,
+    ];
+}

tests/Stubs/ClassesToTransform/StringClass.php → tests/Functional/Cache/CachedFileAndDestructor/Target/StringClass.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target;
 
 class StringClass
 {

tests/Stubs/Transformer/StringTransformer.php → tests/Functional/Cache/CachedFileAndDestructor/Transformer/StringTransformer.php

@@ -1,10 +1,10 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Stubs\Transformer;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Transformer;
 
 use Microsoft\PhpParser\Node\StringLiteral;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\MultipleTransformersClass;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Cache\CachedFileAndDestructor\Target\StringClass;
+use Okapi\CodeTransformer\Tests\Functional\Transformer\MultipleTransformer\TargetClass;
 use Okapi\CodeTransformer\Transformer;
 use Okapi\CodeTransformer\Transformer\Code;
 
@@ -14,7 +14,7 @@ class StringTransformer extends Transformer
 
     public function getTargetClass(): string|array
     {
-        return [StringClass::class, 'Okapi*Tests*StringClass', MultipleTransformersClass::class];
+        return [StringClass::class, 'Okapi*Tests*StringClass', TargetClass::class];
     }
 
     public function transform(Code $code): void

tests/Functional/DeleteCacheFileTest.php → tests/Functional/Cache/DeleteCacheFile/DeleteCacheFileTest.php

@@ -1,10 +1,8 @@
 <?php
 
-namespace Okapi\CodeTransformer\Tests\Functional;
+namespace Okapi\CodeTransformer\Tests\Functional\Cache\DeleteCacheFile;
 
 use Okapi\CodeTransformer\Tests\ClassLoaderMockTrait;
-use Okapi\CodeTransformer\Tests\Stubs\ClassesToTransform\DeleteCacheFileClass;
-use Okapi\CodeTransformer\Tests\Stubs\Kernel\ApplicationKernel;
 use Okapi\CodeTransformer\Tests\Util;
 use Okapi\Filesystem\Filesystem;
 use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
@@ -18,9 +16,9 @@ class DeleteCacheFileTest extends TestCase
     public function testDeleteCacheFileClass(): void
     {
         Util::clearCache();
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $class = DeleteCacheFileClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         $deleteCacheFileClass = new $class();
@@ -32,15 +30,15 @@ public function testDeleteCacheFileClass(): void
 
     public function testCachedDeleteCacheFileClass(): void
     {
-        ApplicationKernel::init();
+        Kernel::init();
 
-        $cachedFilePath = Util::CACHED_CLASSES_TO_TRANSFORM_DIR . '/DeleteCacheFileClass.php';
+        $cachedFilePath = Util::getTransformedFilePath(Target::class);
 
         $this->assertFileExists($cachedFilePath);
         Filesystem::rm($cachedFilePath);
         $this->assertFileDoesNotExist($cachedFilePath);
 
-        $class = DeleteCacheFileClass::class;
+        $class = Target::class;
         $this->assertWillBeTransformed($class);
 
         $deleteCacheFileClass = new $class();