public function testBinding() { $injector = new Injector(null); $injector->bind([Binding::init(HeavyEngine::class)->lazy(), bind("AAA")->toAlias(HeavyEngine::class)]); $engine = $injector->get('AAA'); $this->assertInstanceOf(Engine::class, $engine); }
public function testProvidersSingletonLazy() { // Arrange $injector = new Injector(null); $injector->providers(['BASE_URL' => ValueProvider::init('http://sysvyz.org/')->singleton()->lazy()]); $this->assertEquals($injector->{'BASE_URL'}, 'http://sysvyz.org/'); }
public function __construct(Engine $engine, Injector $injector) { $this->engine = $engine; $this->tire0 = $injector->get('%FRONT_TIRE%'); $this->tire1 = $injector->get('%FRONT_TIRE%'); $this->tire2 = $injector->get('%BACK_TIRE%'); $this->tire3 = $injector->get('%BACK_TIRE%'); $this->name = 'FASTCAR'; }
/** * Car constructor. * @param Engine $engine * @param Injector $injector * @param string $name * @internal param Tire $tire */ public function __construct(Engine $engine, Injector $injector, string $name) { $this->engine = $engine; $this->tire0 = $injector->get(Tire::class); $this->tire1 = $injector->get(Tire::class); $this->tire2 = $injector->get(Tire::class); $this->tire3 = $injector->get(Tire::class); $this->name = $name; }
/** * */ public function testInvoker() { $injector = new Injector(); $injector->provide('%VALUE%', ValueProvider::init(5)); $obj = $injector->{InvokableObject::class}; $invoker = new Invoker($injector); $res = $invoker->invoke($obj, 'execute'); $this->assertEquals($res, 30); }
public function testProvidersSingletonLazy() { $injector = new Injector(null); $injector->providers(['tire' => ValueFactoryProvider::init(function () { return new Tire(); })->lazy()->singleton()]); $this->assertEquals($injector->{'tire'}->type, 'Tire'); $injector->{'tire'}->a = "a"; $this->assertEquals($injector->{'tire'}->a, 'a'); $this->assertNotSame($injector->{'tire'}, $injector->{'tire'}); $this->assertNotInstanceOf(Tire::class, $injector->{'tire'}); $this->assertInstanceOf(LazyProxyObject::class, $injector->{'tire'}); $this->assertInstanceOf(Tire::class, $injector->{'tire'}->getInstance()); $this->assertSame($injector->{'tire'}->getInstance(), $injector->{'tire'}->getInstance()); }
public function invoke($object, $function) { //TODO opimize $reflector = ReflectorFactory::buildReflectorByClassName(get_class($object)); $reflectionMethod = new \ReflectionMethod($object, $function); $params = $reflectionMethod->getParameters(); $ps = []; foreach ($params as $param) { $ps[$param->getName()] = new ReflectiveCRParam($param->getName() . "", $param); } $crMethod = new ReflectiveCRMethod($reflectionMethod, $ps); $dependencies = $reflector->resolveDependencies($crMethod->getParams(), $function); $params = array_map(function ($dependency) { return $this->injector->get($dependency['token']); }, $dependencies); return call_user_func_array([$object, $function], $params); }
<?php namespace Brunt; use Brunt\Provider\Classes\ClassProvider; use BruntTest\Testobjects\Car; use BruntTest\Testobjects\Controller; use BruntTest\Testobjects\ControllerA; use BruntTest\Testobjects\Engine; use BruntTest\Testobjects\FastCar; use BruntTest\Testobjects\HeavyEngine; include_once 'fileloader.php'; $inj = new Injector(); $inj->provide(Car::class, ClassProvider::init(FastCar::class)); $inj->provide(Engine::class, ClassProvider::init(HeavyEngine::class)); $inj->provide(Controller::class, ClassProvider::init(ControllerA::class)); $inj->provide('%BASE_URL%', function () { return 'http://sysvyz.org/'; }); var_dump($inj->get(Car::class)); var_dump($inj->get(Controller::class));
private function buildLazy($count) { $t = microtime(true); $injector = new Injector(); $injector->provide(ControllerA::class, ClassProvider::init(ControllerA::class)->lazy()); $injector->provide('%BASE_URL%', ValueProvider::init('%BASE_URL%')); $arr = []; for ($i = 0; $i < $count; $i++) { $arr[] = $injector->get(ControllerA::class); } return microtime(true) - $t; }
/** * @param Injector $injector * @return mixed */ function get(Injector $injector) { return $injector->get($this->alias); }
public function testProvidersLazySingleton2() { // Arrange $injector = new Injector(null); $injector->providers([Tire::class => ClassProvider::init(HeavyTire::class)->singleton()->lazy()]); /** @var Tire|ProxyTrait $entity */ $entity = $injector->{Tire::class}; $this->assertInstanceOf(Tire::class, $entity); $this->assertInstanceOf(HeavyTire::class, $entity); //not $this->assertEquals($entity->type, 'HeavyTire'); $this->assertSame($entity->getInstance(), $injector->{Tire::class}->getInstance()); $entity->a = "a"; $this->assertEquals("a", $injector->{Tire::class}->a); }
public function testNonInjectableDependencyFail() { // Arrange $injector = new Injector(null); $injector->providers([NonInjectableWrapper::class => ClassProvider::init(NonInjectableWrapper::class)]); /** @var NonInjectableWrapper $wrapper */ try { $wrapper = $injector->get(NonInjectableWrapper::class); $this->assertTrue(false); } catch (InjectableException $e) { $this->assertTrue(true); } }
public function testBindings() { // Arrange $injector = new Injector(null); $injector->bind(bind(Car::class)->toClass(FastCar::class), bind(Engine::class)->toClass(Engine::class)->singleton()); /** @var Car $car */ $car = $injector->get(Car::class); /** @var Engine $engine */ $engine = $injector->get(Engine::class); $this->assertSame($car->engine, $engine); $this->assertNotSame($car->tire0, $car->tire1); $this->assertNotSame($car->tire0, $car->tire2); $this->assertNotSame($car->tire0, $car->tire3); $this->assertNotSame($car->tire1, $car->tire2); $this->assertNotSame($car->tire1, $car->tire3); $this->assertNotSame($car->tire2, $car->tire3); $this->assertInstanceOf(SmallTire::class, $car->tire0); $this->assertInstanceOf(SmallTire::class, $car->tire1); $this->assertInstanceOf(HeavyTire::class, $car->tire2); $this->assertInstanceOf(HeavyTire::class, $car->tire3); }
/** * Read Dependencies And Providers * Make a new (Child)Injector for the requested Object with Providers * Build Dependencies recursively * Build requested Object * * @param Injector $injector * @return mixed */ function get(Injector $injector) { $className = $this->reflector->getClassName(); $dependencies = $this->_getDependencies($className); // print_r($dependencies); if (!empty($dependencies)) { $childInjector = $injector->getChild($this->_getProviders($className)); //recursive build dependencies $params = array_map(function ($dependency) use($childInjector) { return $childInjector->get($dependency['token']); }, $dependencies); } else { $params = []; } return new $className(...array_values($params)); }