GitAuto: [FEATURE] Add Auto-Registration and Dependency Resolution to DI Container in Pancake

README.md

@@ -9,6 +9,16 @@
 
 Documentation: [Read the Docs](https://guibranco.github.io/pancake/)
 
+## Features
+
+- Simplified service management with auto-registration.
+- Automatic resolution of complex dependency graphs.
+- Configurable options to enable or disable auto-registration.
+
+For more details, refer to the [DIContainer Documentation](docs/DIContainer.md).
+
+
+
 ---
 
 ## Table of contents

docs/DIContainer.md

@@ -0,0 +1,63 @@
+# DIContainer Documentation
+
+The `DIContainer` class provides a simple and flexible Dependency Injection (DI) Container with auto-registration and automatic dependency resolution features.
+
+## Features
+
+- **Auto-Registration**: Automatically registers services that are not explicitly registered.
+- **Automatic Dependency Resolution**: Resolves all dependencies, including constructor dependencies, recursively.
+- **Configurable**: Auto-registration can be enabled or disabled as needed.
+
+## Usage
+
+### Enabling Auto-Registration
+
+By default, auto-registration is enabled. You can create a `DIContainer` instance and resolve services without explicit registration:
+
+```php
+$container = new DIContainer();
+$service = $container->resolve(MyService::class);
+```
+
+### Disabling Auto-Registration
+
+To disable auto-registration, pass `false` to the constructor:
+
+```php
+$container = new DIContainer(false);
+```
+
+### Registering Services Explicitly
+
+You can still register services explicitly using `registerSingleton` or `registerTransient`:
+
+```php
+$container->registerSingleton(MyService::class, new MyService());
+$container->registerTransient(MyOtherService::class, function() {
+    return new MyOtherService();
+});
+```
+
+### Handling Dependencies
+
+The container automatically resolves dependencies for services with constructor arguments:
+
+```php
+class MyService {
+    public function __construct(Dependency $dependency) {}
+}
+
+$service = $container->resolve(MyService::class);
+```
+
+## Exception Handling
+
+If a service cannot be resolved, an exception is thrown with a clear message:
+
+- **Service Not Found**: When auto-registration is disabled and a service is not registered.
+- **Cannot Resolve Dependency**: When a dependency cannot be resolved due to missing type hints or non-existent classes.
+
+## Considerations
+
+- Explicitly registered services take precedence over auto-registered services.
+- Ensure that all dependencies have appropriate type hints for successful resolution.

src/DIContainer.php

@@ -0,0 +1,67 @@
+<?php
+
+class DIContainer
+{
+    private $services = [];
+    private $autoRegisterEnabled = true;
+
+    public function __construct($autoRegisterEnabled = true)
+    {
+        $this->autoRegisterEnabled = $autoRegisterEnabled;
+    }
+
+    public function resolve($name)
+    {
+        if (isset($this->services[$name])) {
+            return $this->services[$name];
+        }
+
+        if ($this->autoRegisterEnabled) {
+            return $this->autoRegister($name);
+        }
+
+        throw new Exception("Service not found: $name");
+    }
+
+    private function autoRegister($name)
+    {
+        if (!class_exists($name)) {
+            throw new Exception("Class not found: $name");
+        }
+
+        $reflectionClass = new ReflectionClass($name);
+        $constructor = $reflectionClass->getConstructor();
+
+        if (is_null($constructor)) {
+            return new $name();
+        }
+
+        $parameters = $constructor->getParameters();
+        $dependencies = [];
+
+        foreach ($parameters as $parameter) {
+            $dependencyClass = $parameter->getClass();
+            if (is_null($dependencyClass)) {
+                throw new Exception("Cannot resolve dependency: " . $parameter->getName());
+            }
+            $dependencies[] = $this->resolve($dependencyClass->getName());
+        }
+
+        return $reflectionClass->newInstanceArgs($dependencies);
+    }
+
+    public function setAutoRegisterEnabled(bool $enabled)
+    {
+        $this->autoRegisterEnabled = $enabled;
+    }
+
+    public function registerSingleton($name, $instance)
+    {
+        $this->services[$name] = $instance;
+    }
+
+    public function registerTransient($name, $closure)
+    {
+        $this->services[$name] = $closure();
+    }
+}

tests/DIContainerTest.php

@@ -0,0 +1,73 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+class DIContainerTest extends TestCase
+{
+    public function testAutoRegistration()
+    {
+        $container = new DIContainer();
+        $service = $container->resolve(TestService::class);
+        $this->assertInstanceOf(TestService::class, $service);
+    }
+
+    public function testDependencyResolution()
+    {
+        $container = new DIContainer();
+        $service = $container->resolve(ServiceWithDependencies::class);
+        $this->assertInstanceOf(ServiceWithDependencies::class, $service);
+        $this->assertInstanceOf(Dependency::class, $service->getDependency());
+    }
+
+    public function testAutoRegistrationDisabled()
+    {
+        $this->expectException(Exception::class);
+        $this->expectExceptionMessage('Service not found: UnregisteredService');
+
+        $container = new DIContainer(false);
+        $container->resolve(UnregisteredService::class);
+    }
+
+    public function testExceptionHandlingForUnresolvableDependency()
+    {
+        $this->expectException(Exception::class);
+        $this->expectExceptionMessage('Cannot resolve dependency: unresolvable');
+
+        $container = new DIContainer();
+        $container->resolve(ServiceWithUnresolvableDependency::class);
+    }
+}
+
+class TestService
+{
+}
+
+class Dependency
+{
+}
+
+class ServiceWithDependencies
+{
+    private $dependency;
+
+    public function __construct(Dependency $dependency)
+    {
+        $this->dependency = $dependency;
+    }
+
+    public function getDependency()
+    {
+        return $this->dependency;
+    }
+}
+
+class UnregisteredService
+{
+}
+
+class ServiceWithUnresolvableDependency
+{
+    public function __construct($unresolvable)
+    {
+    }
+}