GitAuto: [FEATURE] Add a Dependency Inversion Container Class to Pancake

README.md

@@ -1,3 +1,9 @@
+# Pancake Framework
+
+## Dependency Inversion Container
+
+The Pancake framework now includes a Dependency Inversion Container (`DIContainer`) that implements the PSR-11 `ContainerInterface`. For detailed usage instructions, refer to the [DIContainer Usage Guide](docs/DIContainerUsage.md).
+
 # pancake
 
 🧰 🛠️ Pancake project - a toolkit for PHP projects.

docs/DIContainerUsage.md

@@ -0,0 +1,56 @@
+# Dependency Inversion Container Usage
+
+The `DIContainer` class in the Pancake framework provides a robust way to manage dependencies in your application. It adheres to the PSR-11 `ContainerInterface` standard, ensuring compatibility with other libraries and frameworks.
+
+## Registering Services
+
+You can register services with the container using the `register`, `registerSingleton`, and `registerTransient` methods.
+
+```php
+$container = new DIContainer();
+
+// Register a singleton service
+$container->registerSingleton('service', function() {
+    return new Service();
+});
+
+// Register a transient service
+$container->registerTransient('transientService', function() {
+    return new TransientService();
+});
+
+// General registration
+$container->register('generalService', function() {
+    return new GeneralService();
+}, true); // true for singleton
+```
+
+## Resolving Services
+
+To resolve a service, use the `get` method. The container will automatically handle dependencies.
+
+```php
+$service = $container->get('service');
+$transientService = $container->get('transientService');
+```
+
+## Best Practices
+
+- **Use Singleton for Shared Instances**: Use `registerSingleton` for services that should maintain state or are expensive to create.
+- **Use Transient for Stateless Services**: Use `registerTransient` for services that do not maintain state and can be recreated easily.
+- **Leverage Automatic Dependency Resolution**: Define dependencies in service constructors and let the container resolve them automatically.
+
+## Example
+
+```php
+$container->registerSingleton('config', function() {
+    return new Config(['setting' => 'value']);
+});
+
+$container->registerSingleton('service', function($c) {
+    $config = $c->get('config');
+    return new Service($config);
+});
+
+$service = $container->get('service');
+```

docs/README.md

@@ -0,0 +1,6 @@
+# Pancake Framework Documentation
+
+## Features
+
+- **Dependency Inversion Container**: The framework includes a DI container that simplifies dependency management and adheres to the PSR-11 standard. See [DIContainer Usage](DIContainerUsage.md) for more details.
+

src/Pancake/DIContainer.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Pancake;
+
+use Psr\Container\ContainerInterface;
+use Psr\Container\NotFoundExceptionInterface;
+use Psr\Container\ContainerExceptionInterface;
+
+class DIContainer implements ContainerInterface
+{
+    private $services = [];
+    private $sharedInstances = [];
+
+    public function register(string $name, callable $resolver, bool $shared = false): void
+    {
+        $this->services[$name] = ['resolver' => $resolver, 'shared' => $shared];
+    }
+
+    public function registerSingleton(string $name, callable $resolver): void
+    {
+        $this->register($name, $resolver, true);
+    }
+
+    public function registerTransient(string $name, callable $resolver): void
+    {
+        $this->register($name, $resolver, false);
+    }
+
+    public function get(string $name)
+    {
+        if (!isset($this->services[$name])) {
+            throw new class () extends \Exception implements NotFoundExceptionInterface {};
+        }
+
+        if ($this->services[$name]['shared']) {
+            if (!isset($this->sharedInstances[$name])) {
+                $this->sharedInstances[$name] = $this->resolve($name);
+            }
+            return $this->sharedInstances[$name];
+        }
+
+        return $this->resolve($name);
+    }
+
+    private function resolve(string $name)
+    {
+        try {
+            return call_user_func($this->services[$name]['resolver'], $this);
+        } catch (\Exception $e) {
+            throw new class () extends \Exception implements ContainerExceptionInterface {};
+        }
+    }
+
+    public function has(string $name): bool
+    {
+        return isset($this->services[$name]);
+    }
+}

tests/DIContainerTest.php

@@ -0,0 +1,64 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+use Pancake\DIContainer;
+
+class DIContainerTest extends TestCase
+{
+    public function testRegisterAndResolveSingleton()
+    {
+        $container = new DIContainer();
+        $container->registerSingleton('service', function () {
+            return new stdClass();
+        });
+
+        $service1 = $container->get('service');
+        $service2 = $container->get('service');
+
+        $this->assertSame($service1, $service2);
+    }
+
+    public function testRegisterAndResolveTransient()
+    {
+        $container = new DIContainer();
+        $container->registerTransient('service', function () {
+            return new stdClass();
+        });
+
+        $service1 = $container->get('service');
+        $service2 = $container->get('service');
+
+        $this->assertNotSame($service1, $service2);
+    }
+
+    public function testServiceNotFound()
+    {
+        $this->expectException(Psr\Container\NotFoundExceptionInterface::class);
+
+        $container = new DIContainer();
+        $container->get('non_existent_service');
+    }
+
+    public function testHasMethod()
+    {
+        $container = new DIContainer();
+        $container->registerSingleton('service', function () {
+            return new stdClass();
+        });
+
+        $this->assertTrue($container->has('service'));
+        $this->assertFalse($container->has('non_existent_service'));
+    }
+
+    public function testExceptionOnResolutionFailure()
+    {
+        $this->expectException(Psr\Container\ContainerExceptionInterface::class);
+
+        $container = new DIContainer();
+        $container->register('service', function () {
+            throw new Exception('Resolution failed');
+        });
+
+        $container->get('service');
+    }
+}

tests/Integration/DIContainerIntegrationTest.php

@@ -0,0 +1,55 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+use Pancake\DIContainer;
+
+class DIContainerIntegrationTest extends TestCase
+{
+    public function testIntegrationWithPancakeFramework()
+    {
+        $container = new DIContainer();
+
+        // Simulate a service with dependencies
+        $container->registerSingleton('config', function () {
+            return ['setting' => 'value'];
+        });
+
+        $container->registerSingleton('service', function ($c) {
+            $config = $c->get('config');
+            $service = new stdClass();
+            $service->config = $config;
+            return $service;
+        });
+
+        $service = $container->get('service');
+
+        $this->assertEquals('value', $service->config['setting']);
+    }
+
+    public function testComplexDependencyChain()
+    {
+        $container = new DIContainer();
+
+        $container->registerSingleton('dependency1', function () {
+            return new stdClass();
+        });
+
+        $container->registerSingleton('dependency2', function ($c) {
+            $dep1 = $c->get('dependency1');
+            $dep2 = new stdClass();
+            $dep2->dep1 = $dep1;
+            return $dep2;
+        });
+
+        $container->registerSingleton('mainService', function ($c) {
+            $dep2 = $c->get('dependency2');
+            $mainService = new stdClass();
+            $mainService->dep2 = $dep2;
+            return $mainService;
+        });
+
+        $mainService = $container->get('mainService');
+
+        $this->assertSame($mainService->dep2->dep1, $container->get('dependency1'));
+    }
+}