wip

composer.json

@@ -34,7 +34,7 @@
     },
     "autoload": {
         "psr-4": {
-            "Ray\\Compiler\\": ["src", "src-deprecated"]
+            "Ray\\Compiler\\": ["src"]
         }
     },
     "autoload-dev": {

docs/exmaple/DevInjectorContext.php

@@ -5,8 +5,6 @@
 use Doctrine\Common\Cache\ApcuCache;
 use Doctrine\Common\Cache\CacheProvider;
 use Ray\Compiler\AbstractInjectorContext;
-use Ray\Compiler\DiCompileModule;
-use Ray\Compiler\FakeCarModule;
 use Ray\Di\AbstractModule;
 use Ray\Di\NullCache;
 

tests/DiCompilerTest.php → test-deprecated/DiCompilerTest.php

@@ -2,16 +2,28 @@
 
 declare(strict_types=1);
 
-namespace Ray\Compiler;
+namespace Ray\test;
 
 use DateTime;
 use PHPUnit\Framework\TestCase;
 use Ray\Aop\ReflectionMethod;
 use Ray\Aop\WeavedInterface;
+use Ray\Compiler\DiCompiler;
 use Ray\Compiler\Exception\Unbound;
+use Ray\Compiler\FakeAop;
+use Ray\Compiler\FakeAopInterface;
+use Ray\Compiler\FakeAopModule;
+use Ray\Compiler\FakeCar;
+use Ray\Compiler\FakeCarInterface;
+use Ray\Compiler\FakeCarModule;
+use Ray\Compiler\FakeInstanceModule;
+use Ray\Compiler\FakeLoggerConsumer;
+use Ray\Compiler\FakeLoggerInject;
+use Ray\Compiler\FakeLoggerModule;
+use Ray\Compiler\FakeNullBindingModule;
+use Ray\Compiler\ScriptInjector;
 use Ray\Di\Name;
 use ReflectionParameter;
-
 use function assert;
 
 class DiCompilerTest extends TestCase

tests/Fake/FakeCarModule.php

@@ -25,6 +25,7 @@ protected function configure()
             [FakeInterceptor::class]
         );
         $this->bind(FakeCar::class);
+        $this->bind(FakeCar2::class);
         $this->bind(FakeRobot::class);
     }
 }

tests/Fake/FakeToBindSingletonModule.php

@@ -12,5 +12,6 @@ class FakeToBindSingletonModule extends AbstractModule
     protected function configure()
     {
         $this->bind(FakeRobotInterface::class)->to(FakeRobot::class)->in(Scope::SINGLETON);
+        $this->bind(FakeDependSingleton::class);
     }
 }

tests/ScriptInjectorTest.php

@@ -6,33 +6,40 @@
 
 use PHPUnit\Framework\TestCase;
 use Ray\Aop\WeavedInterface;
+use Ray\Di\AbstractModule;
 use Ray\Di\Exception\Unbound;
 use Ray\Di\InjectorInterface;
 use Ray\Di\NullModule;
 
 use function assert;
 use function count;
 use function glob;
+use function mkdir;
 use function serialize;
 use function spl_object_hash;
 use function unserialize;
 
-class ScriptInjectorTest extends TestCase
+/**
+ *
+ */
+class CompileInjectorExtendedScriptInjectorTest extends TestCase
 {
-    /** @var ScriptInjector */
+    /** @var CompileInjector */
     private $injector;
 
     protected function setUp(): void
     {
-        deleteFiles(__DIR__ . '/tmp');
-        $this->injector = new ScriptInjector(__DIR__ . '/tmp');
+        @mkdir(__DIR__ . '/tmp/com');
+        $this->injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeCarModule();
+            })
+        );
     }
 
     public function testGetInstance(): FakeCar
     {
-        $diCompiler = new DiCompiler(new FakeCarModule(), __DIR__ . '/tmp');
-        $diCompiler->compile();
-        /** @var FakeCar $car */
         $car = $this->injector->getInstance(FakeCarInterface::class);
         $this->assertInstanceOf(FakeCar::class, $car);
 
@@ -48,63 +55,97 @@ public function testDefaultValueInjected(FakeCar $car): void
     public function testCompileException(): void
     {
         $this->expectException(Unbound::class);
-        $script = new ScriptInjector(__DIR__ . '/tmp');
-        $script->getInstance('invalid-class'); // @phpstan-ignore-line
+        $this->injector->getInstance('invalid-class'); // @phpstan-ignore-line
     }
 
     public function testToPrototype(): void
     {
-        (new DiCompiler(new FakeToBindPrototypeModule(), __DIR__ . '/tmp'))->compile();
-        $instance1 = $this->injector->getInstance(FakeRobotInterface::class);
-        $instance2 = $this->injector->getInstance(FakeRobotInterface::class);
+        $injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToBindPrototypeModule();
+            })
+        );
+        $instance1 = $injector->getInstance(FakeRobotInterface::class);
+        $instance2 = $injector->getInstance(FakeRobotInterface::class);
         $this->assertNotSame(spl_object_hash($instance1), spl_object_hash($instance2));
     }
 
     public function testToSingleton(): void
     {
-        (new DiCompiler(new FakeToBindSingletonModule(), __DIR__ . '/tmp'))->compile();
-        $instance1 = $this->injector->getInstance(FakeRobotInterface::class);
-        $instance2 = $this->injector->getInstance(FakeRobotInterface::class);
+        $injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToBindSingletonModule();
+            })
+        );
+        $instance1 = $injector->getInstance(FakeRobotInterface::class);
+        $instance2 = $injector->getInstance(FakeRobotInterface::class);
         $this->assertSame($instance1, $instance2);
     }
 
     public function testToProviderPrototype(): void
     {
-        (new DiCompiler(new FakeToProviderPrototypeModule(), __DIR__ . '/tmp'))->compile();
-        $instance1 = $this->injector->getInstance(FakeRobotInterface::class);
-        $instance2 = $this->injector->getInstance(FakeRobotInterface::class);
+        $injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToProviderPrototypeModule();
+            })
+        );
+        $instance1 = $injector->getInstance(FakeRobotInterface::class);
+        $instance2 = $injector->getInstance(FakeRobotInterface::class);
         $this->assertNotSame($instance1, $instance2);
     }
 
     public function testToProviderSingleton(): void
     {
-        (new DiCompiler(new FakeToProviderSingletonModule(), __DIR__ . '/tmp'))->compile();
-        $instance1 = $this->injector->getInstance(FakeRobotInterface::class);
-        $instance2 = $this->injector->getInstance(FakeRobotInterface::class);
+        $injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToProviderSingletonModule();
+            })
+        );
+        $instance1 = $injector->getInstance(FakeRobotInterface::class);
+        $instance2 = $injector->getInstance(FakeRobotInterface::class);
         $this->assertSame($instance1, $instance2);
     }
 
     public function testToInstancePrototype(): void
     {
-        (new DiCompiler(new FakeToInstancePrototypeModule(), __DIR__ . '/tmp'))->compile();
-        $instance1 = $this->injector->getInstance(FakeRobotInterface::class);
-        $instance2 = $this->injector->getInstance(FakeRobotInterface::class);
+        $injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToInstancePrototypeModule();
+            })
+        );
+        $instance1 = $injector->getInstance(FakeRobotInterface::class);
+        $instance2 = $injector->getInstance(FakeRobotInterface::class);
         $this->assertNotSame($instance1, $instance2);
     }
 
     public function testToInstanceSingleton(): void
     {
-        (new DiCompiler(new FakeToInstanceSingletonModule(), __DIR__ . '/tmp'))->compile();
-        $instance1 = $this->injector->getInstance(FakeRobotInterface::class);
-        $instance2 = $this->injector->getInstance(FakeRobotInterface::class);
+        $injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToInstanceSingletonModule();
+            })
+        );
+        $instance1 = $injector->getInstance(FakeRobotInterface::class);
+        $instance2 = $injector->getInstance(FakeRobotInterface::class);
         $this->assertSame($instance1, $instance2);
     }
 
     public function testSerializable(): void
     {
-        $diCompiler = new DiCompiler(new FakeCarModule(), __DIR__ . '/tmp');
-        $diCompiler->compile();
-        $injector = unserialize(serialize($this->injector));
+        $originalInjector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToInstanceSingletonModule();
+            })
+        );
+
+        $injector = unserialize(serialize($originalInjector));
         assert($injector instanceof InjectorInterface);
         $car = $injector->getInstance(FakeCarInterface::class);
         $this->assertInstanceOf(ScriptInjector::class, $injector);
@@ -113,9 +154,7 @@ public function testSerializable(): void
 
     public function testAop(): void
     {
-        $compiler = new DiCompiler(new FakeCarModule(), __DIR__ . '/tmp');
-        $compiler->compile();
-        $injector = new ScriptInjector(__DIR__ . '/tmp');
+        $injector = $this->injector;
         $instance1 = $injector->getInstance(FakeCarInterface::class);
         $instance2 = $injector->getInstance(FakeCar::class);
         $instance3 = $injector->getInstance(FakeCar2::class);
@@ -127,22 +166,23 @@ public function testAop(): void
 
     public function testOnDemandSingleton(): void
     {
-        (new DiCompiler(new FakeToBindSingletonModule(), __DIR__ . '/tmp'))->compile();
-        $dependSingleton1 = $this->injector->getInstance(FakeDependSingleton::class);
-        $dependSingleton2 = $this->injector->getInstance(FakeDependSingleton::class);
+        $injector = new CompileInjector(
+            __DIR__ . '/tmp',
+            LazyModule::getInstance(function (): AbstractModule {
+                return new FakeToBindSingletonModule();
+            })
+        );
+        $dependSingleton1 = $injector->getInstance(FakeDependSingleton::class);
+        $dependSingleton2 = $injector->getInstance(FakeDependSingleton::class);
         $hash1 = spl_object_hash($dependSingleton1->robot);
         $hash2 = spl_object_hash($dependSingleton2->robot);
         $this->assertSame($hash1, $hash2);
     }
 
     public function testOnDemandPrototype(): void
     {
-        (new DiCompiler(new FakeCarModule(), __DIR__ . '/tmp'))->compile();
-        $fakeDependPrototype1 = $this->injector->getInstance(FakeDependPrototype::class);
-        $fakeDependPrototype2 = $this->injector->getInstance(FakeDependPrototype::class);
-        $hash1 = spl_object_hash($fakeDependPrototype1->car);
-        $hash2 = spl_object_hash($fakeDependPrototype2->car);
-        $this->assertNotSame($hash1, $hash2);
+        $this->expectException(Unbound::class); // CompileInjector does not support on-demand prototype
+        $this->injector->getInstance(FakeDependPrototype::class);
     }
 
     public function testOptional(): void