Merge pull request #19 from FreeElephants/callable-components

Support callable beans instantiation

Author: samizdam

CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [3.1.0] - 2021-05-17
+### Added:
+- 'callable' di configuration entries support
+
 ### Changed
 - Register itself as PSR Container 
 
@@ -14,7 +18,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - PHP 8 support
 
 ### Changed
-- Check that argument type is not builtin, intead deprecated `ReflectionType::getClass` usage
+- Check that argument type is not builtin, instead deprecated `ReflectionType::getClass` usage
 
 ### Removed
 - PHP 7.1 and 7.2 support
@@ -93,7 +97,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - All classes. 
 
-[Unreleased]: https://github.com/FreeElephants/php-di/compare/3.0.0...HEAD
+[Unreleased]: https://github.com/FreeElephants/php-di/compare/3.1.0...HEAD
+[3.1.0]: https://github.com/FreeElephants/php-di/compare/3.0.0...3.1.0
 [3.0.0]: https://github.com/FreeElephants/php-di/compare/2.1.0...3.0.0
 [2.1.0]: https://github.com/FreeElephants/php-di/compare/2.0.2...2.1.0
 [2.0.2]: https://github.com/FreeElephants/php-di/compare/2.0.1...2.0.2

README.md

@@ -11,7 +11,7 @@ Framework-agnostic Dependency Injection tool and PSR-11 implementation provider.
 
 ## Requirements
 
-PHP >=7.1
+PHP >=7.3|8.0
 
 ## Installation
 
@@ -29,7 +29,8 @@ $app = $di->createInstance(\YourApplication::class);
 $app->run();
 ```
 
-Your `components.php` file with dependencies description shoud look like this:
+Your `components.php` file with dependencies description should look like this:
+
 ```php
 <?php
 
@@ -42,20 +43,37 @@ return [
         \ControllerFactory::class,
         \SomeService::class,
         \AnotherService::class,
-        \Psr\Log\LoggerInterface::class => \Symfony\Component\Console\Logger\ConsoleLogger::class
-        // etc
+        \Psr\Log\LoggerInterface::class => \Symfony\Component\Console\Logger\ConsoleLogger::class,
+    ],
+    'callable' => [ 
+        // if function provided as key value
+        // first argument passed to callable is psr container
+        // second is key
+        Foo::class => function(\Psr\Container\ContainerInterface $container, string $key) {
+           return (new Foo())->setSomething($container->get('something'));
+        },
+        // if array provided as key value
+        // first argument passed to callable is psr container
+        // remaining element as ...args tail
+        Bar::class => [ // array where first element is callable, other is values for last arguments
+            function(\Psr\Container\ContainerInterface $container, $firstArg, string $secondArg) {
+                return new Bar($firstArg, $secondArg);
+            },
+            100,
+            500,
+        ],       
     ],
 ];
 ```
 
 The main idea: all your components should expect all dependencies as constructor arguments.  All other work entrust to Injector.
-You do not have to want instantiate any classes directly in your code. Your must inject some factories instead.   
+You do not have to want to instantiate any classes directly in your code. Your must inject some factories instead.   
 
 ### Override Components by Environments
 
 ```php
 <?php
-// genenv('ENV') -> 'test'
+// getenv('ENV') -> 'test'
 $components = (new \FreeElephants\DI\EnvAwareConfigLoader(__DIR__ . '/config', 'ENV'))->readConfig('components');
 $di = (new \FreeElephants\DI\InjectorBuilder)->buildFromArray($components);
 ```

composer.json

@@ -19,9 +19,9 @@
         }
     ],
     "require": {
-        "psr/log": "~1.0",
+        "psr/log": "^1.0",
         "psr/container": "^1.0",
-        "php": "^7.1|^8.0"
+        "php": "^7.3|^8.0"
     },
     "provide": {
         "psr/container-implementation": "1.0"

src/CallableBeanContainer.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace FreeElephants\DI;
+
+use FreeElephants\DI\Exception\InvalidArgumentException;
+use Psr\Container\ContainerInterface;
+
+class CallableBeanContainer
+{
+    /**
+     * @var callable|mixed|null
+     */
+    private $function;
+    /**
+     * @var array
+     */
+    private $args;
+
+    public function __construct(string $interface, $callable, ContainerInterface $container)
+    {
+        if (is_callable($callable)) {
+            $function = $callable;
+            $args = [$container, $interface];
+        } elseif(is_array($callable)) {
+            $function = array_shift($callable);
+            $args = array_merge([$container], $callable);
+        } else {
+            throw new InvalidArgumentException();
+        }
+
+        $this->function = $function;
+        $this->args = $args;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function __invoke()
+    {
+        return call_user_func($this->function, ...$this->args);
+    }
+}

src/Injector.php

@@ -71,7 +71,7 @@ public function createInstance($class)
                             $constructorParams[] = $arg->getDefaultValue();
                         } else {
                             $extendedMessage = sprintf('%s [Required in %s constructor]', $e->getMessage(), $class);
-                            throw new MissingDependencyException($extendedMessage, null, $e);
+                            throw new MissingDependencyException($extendedMessage, 0, $e);
                         }
                     }
                 } elseif ($arg->isDefaultValueAvailable()) {
@@ -89,7 +89,7 @@ public function createInstance($class)
         return $instance;
     }
 
-    public function registerService(string $implementation, string $interface = null)
+    public function registerService($implementation, string $interface = null)
     {
         $interface = $interface ?: $implementation;
         if (isset($this->serviceMap[$interface])) {
@@ -116,6 +116,10 @@ public function getService(string $type)
             $this->loggerHelper->logLazyLoading($type, $service);
             $service = $this->createInstance($service);
             $this->setService($type, $service);
+        } elseif ($service instanceof CallableBeanContainer) {
+            $this->loggerHelper->logLazyLoading($type, $service);
+            $service = $service();
+            $this->setService($type, $service);
         }
 
         return $service;
@@ -129,7 +133,8 @@ public function hasImplementation(string $interface): bool
     public function merge(
         array $components,
         string $instancesKey = InjectorBuilder::INSTANCES_KEY,
-        string $registerKey = InjectorBuilder::REGISTER_KEY
+        string $registerKey = InjectorBuilder::REGISTER_KEY,
+        string $callableKey = InjectorBuilder::CALLABLE_KEY
     )
     {
         $beansInstances = $components[$instancesKey] ?? [];
@@ -139,13 +144,19 @@ public function merge(
             }
             $this->setService($interface, $instance);
         }
+
         $registeredBeans = $components[$registerKey] ?? [];
         foreach ($registeredBeans as $interface => $implementation) {
             if (is_int($interface)) {
                 $interface = $implementation;
             }
             $this->registerService($implementation, $interface);
         }
+
+        $callableBeans = $components[$callableKey] ?? [];
+        foreach ($callableBeans as $interface => $callable) {
+            $this->registerService(new CallableBeanContainer($interface, $callable, $this), $interface);
+        }
     }
 
     public function allowNullableConstructorArgs(bool $allow)
@@ -191,6 +202,5 @@ public function useIdAsTypeName(bool $useIdAsTypeName = true)
     public function enableLoggerAwareInjection(bool $enable = true)
     {
         $this->enableLoggerAwareInjection = $enable;
-    }
-}
+    }}
 

src/InjectorBuilder.php

@@ -8,7 +8,8 @@
 class InjectorBuilder
 {
     public const INSTANCES_KEY = 'instances';
-    public const REGISTER_KEY = 'register';
+    public const REGISTER_KEY  = 'register';
+    public const CALLABLE_KEY  = 'callable';
     /**
      * @var string
      */
@@ -17,19 +18,28 @@ class InjectorBuilder
      * @var string
      */
     private $registerKey;
+    /**
+     * @var string
+     */
+    private $callableKey;
 
-    public function __construct(string $instancesKey = self::INSTANCES_KEY, string $registerKey = self::REGISTER_KEY)
+    public function __construct(
+        string $instancesKey = self::INSTANCES_KEY,
+        string $registerKey = self::REGISTER_KEY,
+        string $callableKey = self::CALLABLE_KEY
+    )
     {
         $this->instancesKey = $instancesKey;
         $this->registerKey = $registerKey;
+        $this->callableKey = $callableKey;
     }
 
     public function buildFromArray(array $components): Injector
     {
         $injector = new Injector();
 
-        $injector->merge($components, $this->instancesKey, $this->registerKey);
+        $injector->merge($components, $this->instancesKey, $this->registerKey, $this->callableKey);
 
         return $injector;
     }
-}
+}

src/LoggerHelper.php

@@ -38,9 +38,9 @@ public function logLazyLoading(string $interface, $service)
         $this->logger->debug($debugMsg, $context);
     }
 
-    public function logServiceRegistration(string $implementation, string $interface)
+    public function logServiceRegistration($implementation, string $interface)
     {
-        $msg = 'Service with type ' . $interface . ' and implementation ' . $implementation . ' register. ';
+        $msg = 'Service with type ' . $interface . ' and implementation ' . $this->stringifyImplementation($implementation) . ' register. ';
         $context = [
             'interface'      => $interface,
             'implementation' => $implementation,
@@ -69,7 +69,7 @@ public function logServiceInstanceReplacing(string $typeName, $service, $previou
         return [$debugMsg, $context];
     }
 
-    public function logRegisterServiceReplacing(string $implementation, string $interface, $oldImplementation)
+    public function logRegisterServiceReplacing($implementation, string $interface, $oldImplementation)
     {
         $msg = 'Replace registered service type ' . $interface . ' with another. ';
         $context = [
@@ -89,4 +89,14 @@ public function logServiceSetting(string $typeName, $service)
         ];
         $this->logger->debug($debugMsg, $context);
     }
-}
+
+    private function stringifyImplementation($implementation): string
+    {
+        // var_export does not handle circular references
+        // handle this case
+        if($implementation instanceof CallableBeanContainer) {
+            $implementation = 'user defined callable';
+        }
+        return var_export($implementation, true);
+    }
+}

tests/Fixture/Bar.php

@@ -8,4 +8,4 @@
 class Bar
 {
 
-}
+}

tests/InjectorBuilderTest.php

@@ -4,7 +4,9 @@
 
 use Fixture\AnotherService;
 use Fixture\Bar;
+use Fixture\ClassWithDefaultConstructorArgValue;
 use Fixture\Foo;
+use Psr\Container\ContainerInterface;
 
 /**
  * @author samizdam <samizdam@inbox.ru>
@@ -17,17 +19,32 @@ public function testBuildFromArray()
         $builder = new InjectorBuilder();
 
         $anotherServiceInstance = new AnotherService();
+        $bar1 = new Bar();
+        $bar2 = new Bar();
         $injector = $builder->buildFromArray([
             'instances' => [
-                Bar::class => new Bar(),
+                Bar::class => $bar1,
                 $anotherServiceInstance,
             ],
-            'register' => [
+            'register'  => [
                 Foo::class
-            ]
+            ],
+            'callable'  => [
+                ClassWithDefaultConstructorArgValue::class => [
+                    function (ContainerInterface $container, int $value): ClassWithDefaultConstructorArgValue {
+                        return new ClassWithDefaultConstructorArgValue($value);
+                    },
+                    9000,
+                ],
+                Bar::class                                 => function () use ($bar2) {
+                    return $bar2;
+                },
+            ],
         ]);
 
+        $this->assertSame($bar2, $injector->getService(Bar::class));
         $this->assertInstanceOf(Foo::class, $injector->createInstance(Foo::class));
         $this->assertSame($anotherServiceInstance, $injector->getService(AnotherService::class));
+        $this->assertSame(9000, $injector->get(ClassWithDefaultConstructorArgValue::class)->getValue());
     }
-}
+}

tests/InjectorTest.php

@@ -236,5 +236,19 @@ public function testHandleInstantiateInterfaceError()
         $injector->get(SomeService::class);
     }
 
+    public function testGetServiceWithInvalidCallable()
+    {
+        $injector = new Injector();
+
+        $this->expectException(InvalidArgumentException::class);
+
+        $injector->merge([
+            InjectorBuilder::CALLABLE_KEY => [
+                'foo' => 'not_callable',
+            ],
+        ]);
+    }
+
+
 }