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));
}
