Refactored code

Author: WalterWoshid

.editorconfig

@@ -10,6 +10,7 @@ ij_php_align_key_value_pairs = true
 ij_php_align_multiline_parameters_in_calls = true
 ij_php_align_phpdoc_comments = true
 ij_php_align_phpdoc_param_names = true
+ij_php_blank_lines_before_package = 0
 ij_php_comma_after_last_argument = true
 ij_php_comma_after_last_array_element = true
 ij_php_comma_after_last_closure_use_var = true

README.md

@@ -112,12 +112,12 @@ class StringTransformer extends Transformer
     {
         // I recommend using the Microsoft\PhpParser library to parse the source
         // code. It's already included in the dependencies of this package and
-        // the "$code->sourceFileNode" property contains the parsed source code.
+        // the "$code->getSourceFileNode()" property contains the parsed source code.
 
         // But you can also use any other library or manually parse the source
         // code with basic PHP string functions and "$code->getOriginalSource()"
 
-        $sourceFileNode = $code->sourceFileNode;
+        $sourceFileNode = $code->getSourceFileNode();
 
         // Iterate over all nodes
         foreach ($sourceFileNode->getDescendantNodes() as $node) {
@@ -168,7 +168,7 @@ class UnPrivateTransformer extends Transformer
 
     public function transform(Code $code): void
     {
-        $sourceFileNode = $code->sourceFileNode;
+        $sourceFileNode = $code->getSourceFileNode();
 
         // Iterate over all tokens
         foreach ($sourceFileNode->getDescendantTokens() as $token) {

TODO.md

@@ -0,0 +1,24 @@
+# 1. Class Name matching
+Optimize the class name matching by using efficient data structures or 
+algorithms (e.g. trie-based matching or regular expressions).
+
+# 2. Cache management
+More sophisticated cache management strategy, such as Least Recently Used (LRU) 
+or Time-To-Live (TTL) based eviction, to ensure that cache remains up-to-date 
+and efficient.
+
+# 3. Parallelization
+Parallelize the process of matching and transforming classes and methods to 
+reduce the overall processing time.
+
+# 4. Incremental updates
+Incremental update mechanism to process only new or changed classes and methods.
+
+# 5. Monitoring
+Monitor the performance of the library to identify bottlenecks and areas that 
+need optimization (e.g. Profilers or benchmarking suites).
+
+# 6. Documentation
+- Document how to use xdebug with php-unit tests that use the 
+  `#[RunTestsInSeparateProcesses]` attribute (PhpStorm)
+- Create a flowchart

composer.json

@@ -28,7 +28,9 @@
         "okapi/filesystem": "^1.0",
         "okapi/path": "^1.0",
         "okapi/singleton": "^1.0",
-        "okapi/wildcards": "^1.0"
+        "okapi/wildcards": "^1.0",
+        "php-di/php-di": "^7.0",
+        "roave/better-reflection": "^6.8"
     },
     "require-dev": {
         "phpunit/phpunit": "dev-main",

src/CodeTransformerKernel.php

@@ -2,9 +2,11 @@
 
 namespace Okapi\CodeTransformer;
 
+use DI\Attribute\Inject;
 use Okapi\CodeTransformer\Exception\Kernel\DirectKernelInitializationException;
 use Okapi\CodeTransformer\Service\AutoloadInterceptor;
 use Okapi\CodeTransformer\Service\CacheStateManager;
+use Okapi\CodeTransformer\Service\DI;
 use Okapi\CodeTransformer\Service\Options;
 use Okapi\CodeTransformer\Service\StreamFilter;
 use Okapi\CodeTransformer\Service\TransformerContainer;
@@ -24,55 +26,127 @@ abstract class CodeTransformerKernel
 {
     use Singleton;
 
+    // region Settings
+
+    /**
+     * The cache directory.
+     * <br><b>Default:</b> ROOT_DIR/cache/code-transformer<br>
+     *
+     * @var string|null
+     */
+    protected ?string $cacheDir = null;
+
+    /**
+     * The cache file mode.
+     * <br><b>Default:</b> 0777 & ~{@link umask()}<br>
+     *
+     * @var int|null
+     */
+    protected ?int $cacheFileMode = null;
+
+    /**
+     * Enable debug mode. This will disable the cache.
+     * <br><b>Default:</b> false<br>
+     *
+     * @var bool
+     */
+    protected bool $debug = false;
+
+    // endregion
+
     /**
      * List of transformers to be applied.
      *
      * @var class-string<Transformer>[]
      */
     protected array $transformers = [];
 
+    // region DI
+
+    #[Inject]
+    private Options $options;
+
+    #[Inject]
+    protected TransformerContainer $transformerContainer;
+
+    #[Inject]
+    private CacheStateManager $cacheStateManager;
+
+    #[Inject]
+    private StreamFilter $streamFilter;
+
+    #[Inject]
+    private AutoloadInterceptor $autoloadInterceptor;
+
     /**
-     * Initialize the kernel.
+     * Make the constructor public to allow the DI container to instantiate the class.
+     */
+    public function __construct() {}
+
+    // endregion
+
+    /**
+     * Resolve instance with dependency injection.
      *
-     * @param string|null $cacheDir      The cache directory.
-     *                                   <br><b>Default:</b> ROOT_DIR/cache/code-transformer<br>
-     * @param int|null    $cacheFileMode The cache file mode.
-     *                                   <br><b>Default:</b> 0777 & ~{@link umask()}<br>
-     * @param bool|null   $debug         Enable debug mode. This will disable the cache.
-     *                                   <br><b>Default:</b> false<br>
+     * @inheritDoc
+     */
+    public static function getInstance(): static
+    {
+        if (!isset(static::$instance)) {
+            static::registerDependencyInjection();
+
+            static::$instance = DI::get(static::class);
+        }
+
+        return static::$instance;
+    }
+
+    /**
+     * Initialize the kernel.
      *
      * @return void
      */
-    public static function init(
-        ?string $cacheDir,
-        ?int    $cacheFileMode = null,
-        bool    $debug = false,
-    ): void {
-        self::ensureNotKernelNamespace();
-
-        $instance = self::getInstance();
-        $instance->ensureNotInitialized();
+    public static function init(): void
+    {
+        static::ensureNotKernelNamespace();
 
-        // Only initialize the kernel if there are transformers
-        if ($instance->transformers) {
-            // Pre-initialize the services
+        $instance = static::getInstance();
+        $instance->ensureNotInitialized();
 
-            // Set options
-            Options::setOptions(
-                cacheDir:      $cacheDir,
-                cacheFileMode: $cacheFileMode,
-                debug:         $debug,
-            );
+        // Initialize the services
+        $instance->preInit();
+        $instance->registerServices();
+        $instance->registerAutoloadInterceptor();
 
-            // Add the transformers
-            TransformerContainer::addTransformers($instance->transformers);
+        $instance->setInitialized();
+    }
 
-            // Register the services
-            $instance->registerServices();
-            $instance->registerAutoloadInterceptor();
-        }
+    /**
+     * Register the dependency injection.
+     *
+     * @return void
+     */
+    protected static function registerDependencyInjection(): void
+    {
+        DI::getInstance()->register();
+    }
 
-        $instance->setInitialized();
+    /**
+     * Pre-initialize the services.
+     *
+     * @return void
+     */
+    protected function preInit(): void
+    {
+        // Set options
+        $this->options->setOptions(
+            cacheDir:      $this->cacheDir,
+            cacheFileMode: $this->cacheFileMode,
+            debug:         $this->debug,
+        );
+
+        // Add the transformers
+        $this->transformerContainer->addTransformers($this->transformers);
     }
 
     /**
@@ -83,16 +157,16 @@ public static function init(
     protected function registerServices(): void
     {
         // Options provider
-        Options::register();
+        $this->options->register();
 
         // Manage the user-defined transformers
-        TransformerContainer::register();
+        $this->transformerContainer->register();
 
         // Cache path manager
-        CacheStateManager::register();
+        $this->cacheStateManager->register();
 
         // Stream filter -> Source transformer
-        StreamFilter::register();
+        $this->streamFilter->register();
     }
 
     /**
@@ -103,15 +177,15 @@ protected function registerServices(): void
     protected function registerAutoloadInterceptor(): void
     {
         // Overload the composer class loaders
-        AutoloadInterceptor::register();
+        $this->autoloadInterceptor->register();
     }
 
     /**
      * Make sure that the kernel is not called from this class.
      *
      * @return void
      */
-    private static function ensureNotKernelNamespace(): void
+    protected static function ensureNotKernelNamespace(): void
     {
         // Get current namespace and class name
         $namespace = get_called_class();

src/Exception/Transformer/InvalidTransformerClassException.php

@@ -13,13 +13,13 @@
 class InvalidTransformerClassException extends TransformerException
 {
     /**
-     * Create a new `TransformerMissingInterfaceException` instance.
+     * InvalidTransformerClassException constructor.
      *
      * @param class-string $transformerClass
      */
     public function __construct(string $transformerClass) {
         parent::__construct(
-            message: "Transformer class '$transformerClass' does not extend the Transformer class.",
+            "Transformer class '$transformerClass' does not extend the Transformer class.",
         );
     }
 }

src/Exception/Transformer/SyntaxError.php

@@ -25,7 +25,7 @@ public function __construct(
         ?SyntaxError $previous = null
     ) {
         parent::__construct(
-            "Syntax error in transformed code: $diagnostic->message\n\nFull code:\n$code",
+            "Syntax error in transformed code: $diagnostic->message\n\nFull code:\n```php\n$code\n```",
             previous: $previous,
         );
     }

src/Exception/Transformer/TransformerNotFoundException.php

@@ -12,14 +12,14 @@
 class TransformerNotFoundException extends TransformerException
 {
     /**
-     * Create a new instance of the exception.
+     * TransformerNotFoundException constructor.
      *
      * @param class-string $transformerClass
      */
     public function __construct(string $transformerClass)
     {
         parent::__construct(
-            message: "Transformer class '$transformerClass' does not exist.",
+            "Transformer class '$transformerClass' does not exist.",
         );
     }
 }

src/Service/AutoloadInterceptor.php

@@ -3,8 +3,7 @@
 namespace Okapi\CodeTransformer\Service;
 
 use Composer\Autoload\ClassLoader as ComposerClassLoader;
-use Okapi\CodeTransformer\Service\AutoloadInterceptor\ClassLoader;
-use Okapi\Singleton\Singleton;
+use Okapi\CodeTransformer\Service\ClassLoader\ClassLoader;
 
 /**
  * # Autoload Interceptor
@@ -20,22 +19,20 @@
  */
 class AutoloadInterceptor implements ServiceInterface
 {
-    use Singleton;
+    /**
+     * The DI key for the original composer class loader.
+     */
+    public const DI = 'okapi.code-transformer.service.composer.class-loader';
 
     /**
      * Register the autoload interceptor.
      *
      * @return void
      */
-    public static function register(): void
+    public function register(): void
     {
-        $instance = self::getInstance();
-        $instance->ensureNotInitialized();
-
         // Overload existing composer loaders
-        $instance->overloadComposerLoaders();
-
-        $instance->setInitialized();
+        $this->overloadComposerLoaders();
     }
 
     /**
@@ -60,8 +57,14 @@ private function overloadComposerLoaders(): void
                 // @codeCoverageIgnoreEnd
             }
 
+            // Get the original composer loader
+            $original = $loader[0];
+            DI::set(self::DI, $original);
+
             // Register the AOP class loader
-            $loader[0] = new ClassLoader($loader[0]);
+            $loader[0] = DI::make(ClassLoader::class, [
+                'original' => $original,
+            ]);
 
             // Unregister the original composer loader
             spl_autoload_unregister($loaderToUnregister);