public function configureDi(Di $di) { $di->instanceManager()->addSharedInstance($this->configurationReader, get_class($this->configurationReader)); $di->instanceManager()->addSharedInstance($this->classConfigurationReader, get_class($this->classConfigurationReader)); $di->instanceManager()->addSharedInstance($this->environmentConfigurationReader, get_class($this->environmentConfigurationReader)); $di->instanceManager()->addSharedInstance($this, get_class($this)); }
/** * Set up dependency injection framework * * @return ServiceManager */ public function init() { $options = $this->getOptions(); $doctrineContainer = $this->getBootstrap()->bootstrap('Doctrine')->getResource('Doctrine'); $di = new ZendDi\Di(null, null, new ZendDi\Config($options)); $di->instanceManager()->addSharedInstance(new Db\Adapter\Driver\Pdo\Pdo($doctrineContainer->getEntityManager()->getConnection()->getWrappedConnection()), 'Zend\\Db\\Adapter\\Driver\\Pdo\\Pdo'); $di->instanceManager()->addSharedInstance($doctrineContainer->getEntityManager(), 'Doctrine\\ORM\\EntityManager'); return $di; }
public function render() { $knownClasses = array(); echo 'Definitions' . PHP_EOL . PHP_EOL; foreach ($this->di->definitions() as $definition) { $this->renderDefinition($definition); foreach ($definition->getClasses() as $class) { $knownClasses[] = $class; $this->renderClassDefinition($definition, $class); } if (count($definition->getClasses()) == 0) { echo PHP_EOL . ' No Classes Found' . PHP_EOL . PHP_EOL; } } if ($this->runtimeClasses) { echo ' Runtime classes:' . PHP_EOL; } $unknownRuntimeClasses = array_diff($this->runtimeClasses, $knownClasses); foreach ($unknownRuntimeClasses as $runtimeClass) { $definition = $this->di->definitions()->getDefinitionForClass($runtimeClass); $this->renderClassDefinition($definition, $runtimeClass); } echo PHP_EOL . 'Instance Configuration Info:' . PHP_EOL; echo PHP_EOL . ' Aliases:' . PHP_EOL; $configuredTypes = array(); foreach ($this->di->instanceManager()->getAliases() as $alias => $class) { echo ' ' . $alias . ' [type: ' . $class . ']' . PHP_EOL; $configuredTypes[] = $alias; } echo PHP_EOL . ' Classes:' . PHP_EOL; foreach ($this->di->instanceManager()->getClasses() as $class) { echo ' ' . $class . PHP_EOL; $configuredTypes[] = $class; } echo PHP_EOL . ' Configurations:' . PHP_EOL; foreach ($configuredTypes as $type) { $info = $this->di->instanceManager()->getConfiguration($type); echo ' ' . $type . PHP_EOL; if ($info['parameters']) { echo ' parameters:' . PHP_EOL; foreach ($info['parameters'] as $param => $value) { echo ' ' . $param . ' = ' . $value . PHP_EOL; } } if ($info['injections']) { echo ' injections:' . PHP_EOL; foreach ($info['injections'] as $injection => $value) { var_dump($injection, $value); } } } }
/** * @param string $definitionsFile * @param Zend\Di\Di $diInstance */ public function __construct($definitionsFile = null, Zend\Di\Di $diInstance = null) { Magento_Profiler::start('di'); if (is_file($definitionsFile) && is_readable($definitionsFile)) { $definition = new Magento_Di_Definition_ArrayDefinition_Zend(unserialize(file_get_contents($definitionsFile))); } else { $definition = new Magento_Di_Definition_RuntimeDefinition_Zend(); } $this->_di = $diInstance ? $diInstance : new Magento_Di(); $this->_di->setDefinitionList(new Magento_Di_DefinitionList_Zend($definition)); $this->_di->instanceManager()->addSharedInstance($this, 'Magento_ObjectManager'); Magento_Profiler::stop('di'); }
public function render(Di $di) { echo 'Definitions: ' . PHP_EOL; foreach ($di->definitions() as $definition) { foreach ($definition->getClasses() as $class) { echo PHP_EOL . ' Parameters For Class: ' . $class . PHP_EOL; foreach ($definition->getMethods($class) as $methodName => $methodIsRequired) { foreach ($definition->getMethodParameters($class, $methodName) as $fqName => $pData) { echo ' ' . $pData[0] . ' [type: '; echo ($pData[1]) ? $pData[1] : 'scalar'; echo ($pData[2] === true && $methodIsRequired) ? ', required' : ', not required'; echo ', injection-method: ' . $methodName; echo ' fq-name: ' . $fqName; echo ']' . PHP_EOL; } } } } echo PHP_EOL . 'Instance Configuration Info:' . PHP_EOL; echo PHP_EOL . ' Aliases:' . PHP_EOL; $configuredTypes = array(); foreach ($di->instanceManager()->getAliases() as $alias => $class) { echo ' ' . $alias . ' [type: ' . $class . ']' . PHP_EOL; $configuredTypes[] = $alias; } echo PHP_EOL . ' Classes:' . PHP_EOL; foreach ($di->instanceManager()->getClasses() as $class) { echo ' ' . $class . PHP_EOL; $configuredTypes[] = $class; } echo PHP_EOL . ' Configurations:' . PHP_EOL; foreach ($configuredTypes as $type) { $info = $di->instanceManager()->getConfiguration($type); echo ' ' . $type . PHP_EOL; foreach ($info['parameters'] as $param => $value) { echo ' ' . $param . ' = ' . $value . PHP_EOL; } } }
public function setUp() { $this->mock = $this->getMock('Tillikum\\Billing\\Event\\Strategy\\StrategyInterface'); $di = new Di\Di(); $im = $di->instanceManager(); $im->addSharedInstance($this->mock, 'TestStrategyAlias'); $this->processor = new BookingProcessor($di); $rule = new FacilityBookingRule(); $config = new FacilityBookingRuleConfig(); $config->amount = 10.0; $config->currency = 'USD'; $config->start = new DateTime('2010-07-01'); $config->end = new DateTime('2010-07-15'); $config->strategy = 'TestStrategyAlias'; $rule->configs->add($config); $config = new FacilityBookingRuleConfig(); $config->amount = 20.0; $config->currency = 'USD'; $config->start = new DateTime('2010-07-15'); $config->end = new DateTime('2010-07-31'); $config->strategy = 'TestStrategyAlias'; $rule->configs->add($config); $this->event = new FacilityBookingEvent(); $this->event->start = new DateTime('2010-07-01'); $this->event->end = new DateTime('2010-07-15'); $this->event->rule = $rule; }
public function testConfigurationCanConfigureInstanceManagerWithIniFile() { $ini = new \Zend\Config\Ini(__DIR__ . '/_files/sample.ini', 'section-a'); $config = new Configuration($ini->di); $di = new Di(); $di->configure($config); $im = $di->instanceManager(); $this->assertTrue($im->hasAlias('my-repository')); $this->assertEquals('My\RepositoryA', $im->getClassFromAlias('my-repository')); $this->assertTrue($im->hasAlias('my-mapper')); $this->assertEquals('My\Mapper', $im->getClassFromAlias('my-mapper')); $this->assertTrue($im->hasAlias('my-dbAdapter')); $this->assertEquals('My\DbAdapter', $im->getClassFromAlias('my-dbAdapter')); $this->assertTrue($im->hasTypePreferences('my-repository')); $this->assertContains('my-mapper', $im->getTypePreferences('my-repository')); $this->assertTrue($im->hasTypePreferences('my-mapper')); $this->assertContains('my-dbAdapter', $im->getTypePreferences('my-mapper')); $this->assertTrue($im->hasConfiguration('My\DbAdapter')); $expected = array('parameters' => array('username' => 'readonly', 'password' => 'mypassword'), 'injections' => array()); $this->assertEquals($expected, $im->getConfiguration('My\DbAdapter')); $this->assertTrue($im->hasConfiguration('my-dbAdapter')); $expected = array('parameters' => array('username' => 'readwrite'), 'injections' => array()); $this->assertEquals($expected, $im->getConfiguration('my-dbAdapter')); }
public function createService(ServiceLocatorInterface $oServiceLocator) { $oServiceLocator = $oServiceLocator->getServiceLocator(); $oAppService = $oServiceLocator->get('AppService'); $oDi = new Di(); $oDi->instanceManager()->setParameters('API\\Controller\\IndexController', array('app' => $oAppService)); return $oDi->get('API\\Controller\\IndexController'); }
public function testWillDiscoverInjectedMethodParameters() { $di = new Di(); $a = new A(); $di->instanceManager()->setParameters('ZendTest\\Di\\TestAsset\\SetterInjection\\B', array('a' => $a)); $proxy = new DependencyInjectorProxy($di); $b = $proxy->get('ZendTest\\Di\\TestAsset\\SetterInjection\\B'); $methods = $b->getMethods(); $this->assertSame('setA', $methods[0]['method']); $this->assertSame($a, $methods[0]['params'][0]); }
/** * Initialize and register the class via Dependency Injection * * @param string $alias * @param string $class * @param array $parameters */ public function newInstance($alias, $class, array $parameters = []) { try { $this->checkExists($alias); if (!empty($parameters)) { static::$di->instanceManager()->setParameters($class, $parameters); } $this->services[$alias] = static::$di->newInstance($class); } catch (\InvalidArgumentException $e) { throw $e; } }
/** * Retrieves all classes that are involved in generating an instance for $name and its dependencies * * @param array|string $name * @return string[] */ public function getClasses($name) { $classes = array(); $instanceDefinitions = $this->getInjectedDefinitions($name); foreach ($instanceDefinitions as $instanceDefinition) { if ($instanceDefinition->getClass()) { $classes[$instanceDefinition->getClass()] = true; continue; } $alias = $this->di->instanceManager()->getClassFromAlias($instanceDefinition->getName()); $classes[$alias] = true; } return array_keys($classes); }
public function switchThemeConfiguration($fullyQualifiedClassName) { $reflection = new \ReflectionClass($fullyQualifiedClassName); if ($reflection->implementsInterface('Magium\\Themes\\ThemeConfigurationInterface')) { $this->baseThemeClass = $fullyQualifiedClassName; $this->di->instanceManager()->unsetTypePreferences('Magium\\Themes\\ThemeConfigurationInterface'); $this->di->instanceManager()->setTypePreference('Magium\\Themes\\ThemeConfigurationInterface', [$fullyQualifiedClassName]); if ($reflection->implementsInterface('Magium\\Themes\\BaseThemeInterface')) { $this->di->instanceManager()->unsetTypePreferences('Magium\\Themes\\BaseThemeInterface'); $this->di->instanceManager()->setTypePreference('Magium\\Themes\\BaseThemeInterface', [$fullyQualifiedClassName]); } $theme = $this->getTheme(); if ($theme instanceof BaseThemeInterface) { $theme->configure($this); } } else { throw new InvalidConfigurationException('The theme configuration implement Magium\\Themes\\ThemeConfigurationInterface'); } $this->getLogger()->addCharacteristic(Logger::CHARACTERISTIC_THEME, $fullyQualifiedClassName); }
/** * Configures a given Di instance * * @param Di $di * @param $instanceData */ public function configureInstance(Di $di, $instanceData) { $im = $di->instanceManager(); foreach ($instanceData as $target => $data) { switch (strtolower($target)) { case 'aliases': case 'alias': foreach ($data as $n => $v) { $im->addAlias($n, $v); } break; case 'preferences': case 'preference': foreach ($data as $n => $v) { if (is_array($v)) { foreach ($v as $v2) { $im->addTypePreference($n, $v2); } } else { $im->addTypePreference($n, $v); } } break; default: foreach ($data as $n => $v) { switch ($n) { case 'parameters': case 'parameter': $im->setParameters($target, $v); break; case 'injections': case 'injection': $im->setInjections($target, $v); break; case 'shared': case 'share': $im->setShared($target, $v); break; } } } } }
/** * Fix for PHP bug in is_subclass_of * * @see https://bugs.php.net/bug.php?id=53727 */ public function testNewInstanceWillUsePreferredClassForInterfaceHints() { $di = new Di(); $di->instanceManager()->addTypePreference( 'ZendTest\Di\TestAsset\PreferredImplClasses\A', 'ZendTest\Di\TestAsset\PreferredImplClasses\BofA' ); $c = $di->get('ZendTest\Di\TestAsset\PreferredImplClasses\C'); $a = $c->a; $this->assertInstanceOf('ZendTest\Di\TestAsset\PreferredImplClasses\BofA', $a); $d = $di->get('ZendTest\Di\TestAsset\PreferredImplClasses\D'); $this->assertSame($a, $d->a); }
public function testInjectionCanHandleMultipleInjectionsWithMultipleArguments() { $definitionList = new DefinitionList(array($classdef = new Definition\ClassDefinition('ZendTest\\Di\\TestAsset\\InjectionClasses\\A'), new Definition\RuntimeDefinition())); $classdef->addMethod('injectSplitDependency'); $classdef->addMethodParameter('injectSplitDependency', 'b', array('required' => true, 'type' => 'ZendTest\\Di\\TestAsset\\InjectionClasses\\B')); $classdef->addMethodParameter('injectSplitDependency', 'somestring', array('required' => true, 'type' => null)); /** * First test that this works with a single call */ $di = new Di($definitionList); $di->instanceManager()->setInjections('ZendTest\\Di\\TestAsset\\InjectionClasses\\A', array('injectSplitDependency' => array('b' => 'ZendTest\\Di\\TestAsset\\InjectionClasses\\B', 'somestring' => 'bs-id'))); $a = $di->newInstance('ZendTest\\Di\\TestAsset\\InjectionClasses\\A'); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\InjectionClasses\\B', $a->bs[0]); $this->assertEquals('bs-id', $a->bs[0]->id); /** * Next test that this works with multiple calls */ $di = new Di($definitionList); $di->instanceManager()->setInjections('ZendTest\\Di\\TestAsset\\InjectionClasses\\A', array('injectSplitDependency' => array(array('b' => 'ZendTest\\Di\\TestAsset\\InjectionClasses\\B', 'somestring' => 'bs-id'), array('b' => 'ZendTest\\Di\\TestAsset\\InjectionClasses\\C', 'somestring' => 'bs-id-for-c')))); $a = $di->newInstance('ZendTest\\Di\\TestAsset\\InjectionClasses\\A'); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\InjectionClasses\\B', $a->bs[0]); $this->assertEquals('bs-id', $a->bs[0]->id); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\InjectionClasses\\C', $a->bs[1]); $this->assertEquals('bs-id-for-c', $a->bs[1]->id); }
/** * @param \Zend\Di\Di $di * @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator * @param null|DiInstanceManagerProxy $diImProxy */ public function __construct(Di $di, ServiceLocatorInterface $serviceLocator, DiInstanceManagerProxy $diImProxy = null) { $this->di = $di; $this->serviceLocator = $serviceLocator; $this->diInstanceManagerProxy = $diImProxy ?: new DiInstanceManagerProxy($di->instanceManager(), $serviceLocator); }
/** * @expectedException Zend\ServiceManager\Exception\ServiceNotCreatedException */ public function testDoNotFallbackToAbstractFactory() { $factory = function ($sm) { return new TestAsset\Bar(); }; $serviceManager = new ServiceManager(); $serviceManager->setFactory('ZendTest\ServiceManager\TestAsset\Bar', $factory); $di = new Di(); $di->instanceManager()->setParameters('ZendTest\ServiceManager\TestAsset\Bar', array('foo' => array('a'))); $serviceManager->addAbstractFactory(new DiAbstractServiceFactory($di)); $bar = $serviceManager->get('ZendTest\ServiceManager\TestAsset\Bar'); }
/** * @group SetterInjection * @group SupertypeResolution */ public function testInjectionForSetterInjectionWillConsultSupertypeDefinitions() { $di = new Di(); // for setter injection, the dependency is not required, thus it must be forced $di->instanceManager()->setParameters('ZendTest\\Di\\TestAsset\\SetterInjection\\C', array('a' => new TestAsset\SetterInjection\A())); $c = $di->get('ZendTest\\Di\\TestAsset\\SetterInjection\\C'); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\SetterInjection\\C', $c); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\SetterInjection\\A', $c->a); }
/** * Object initialization * * @param Di $di Dependency injection */ public function __construct(Di $di) { $this->_di = $di; $this->_im = $di->instanceManager(); }
public function testPeeringServiceFallbackOnCreateFailure() { $factory = function ($sm) { return new TestAsset\Bar(); }; $serviceManager = new ServiceManager(); $serviceManager->setFactory('ZendTest\\ServiceManager\\TestAsset\\Bar', $factory); $sm = $serviceManager->createScopedServiceManager(ServiceManager::SCOPE_CHILD); $di = new Di(); $di->instanceManager()->setParameters('ZendTest\\ServiceManager\\TestAsset\\Bar', array('foo' => array('a'))); $sm->addAbstractFactory(new DiAbstractServiceFactory($di)); $bar = $serviceManager->get('ZendTest\\ServiceManager\\TestAsset\\Bar'); $this->assertInstanceOf('ZendTest\\ServiceManager\\TestAsset\\Bar', $bar); }
/** * @group SharedInstance */ public function testGetWithParamsWillUseSharedInstance() { $di = new Di(); $sharedInstanceClass = 'ZendTest\\Di\\TestAsset\\ConstructorInjection\\A'; $retrievedInstanceClass = 'ZendTest\\Di\\TestAsset\\ConstructorInjection\\C'; // Provide definitions for $retrievedInstanceClass, but not for $sharedInstanceClass. $arrayDefinition = array($retrievedInstanceClass => array('supertypes' => array(), 'instantiator' => '__construct', 'methods' => array('__construct' => true), 'parameters' => array('__construct' => array("{$retrievedInstanceClass}::__construct:0" => array('a', $sharedInstanceClass, true, NULL), "{$retrievedInstanceClass}::__construct:1" => array('params', NULL, false, array()))))); // This also disables scanning of class A. $di->setDefinitionList(new DefinitionList(new Definition\ArrayDefinition($arrayDefinition))); $di->instanceManager()->addSharedInstance(new $sharedInstanceClass(), $sharedInstanceClass); $returnedC = $di->get($retrievedInstanceClass, array('params' => array('test'))); $this->assertInstanceOf($retrievedInstanceClass, $returnedC); }
public function testDiWillInjectDependenciesForAlias() { $di = new Di; // for setter injection, the dependency is not required, thus it must be forced $classDef = new Definition\ClassDefinition('ZendTest\Di\TestAsset\SetterInjection\B'); $classDef->addMethod('setA', false); $classDef->addMethodParameter('setA', 'a', array('type' => 'ZendTest\Di\TestAsset\SetterInjection\A', 'required' => false)); $di->definitions()->addDefinition($classDef, false); $di->instanceManager()->addAlias('b_alias', 'ZendTest\Di\TestAsset\SetterInjection\B'); $di->instanceManager()->setInjections('b_alias', array('ZendTest\Di\TestAsset\SetterInjection\A')); $b = $di->get('b_alias'); $this->assertInstanceOf('ZendTest\Di\TestAsset\SetterInjection\A', $b->a); }
public function testInjectionForSetterInjectionWillNotUseSupertypeWhenChildParamIsExplicitlyDefined() { $di = new Di(); // for setter injection, the dependency is not required, thus it must be forced $di->instanceManager()->setParameters('ZendTest\\Di\\TestAsset\\InheritanceClasses\\B', array('test' => 'b')); $di->instanceManager()->setParameters('ZendTest\\Di\\TestAsset\\InheritanceClasses\\A', array('test' => 'a')); $b = $di->get('ZendTest\\Di\\TestAsset\\InheritanceClasses\\B'); $this->assertEquals('b', $b->test); $c = $di->get('ZendTest\\Di\\TestAsset\\InheritanceClasses\\C'); $this->assertEquals('b', $c->test); }
public function getAppId() { $config = $this->locator->instanceManager()->getConfiguration('facebook'); return $this->canPropagateUserConfigToDi() ? $this->config['appId'] : $config['parameters']['config']['appId']; }
/** * @param Di $di */ public function __construct(Di $di) { $this->di = $di; $this->definitions = $di->definitions(); $this->instanceManager = $di->instanceManager(); }
public function testAliasesWithDeffrentParams() { $config = array('instance' => array('preference' => array('ZendTest\\Di\\TestAsset\\ConstructorInjection\\A' => 'ZendTest\\Di\\TestAsset\\ConstructorInjection\\E'))); $di = new Di(null, null, new Config($config)); $im = $di->instanceManager(); $im->addAlias('foo', 'ZendTest\\Di\\TestAsset\\ConstructorInjection\\F', array('params' => array('p' => 'vfoo'))); $im->addAlias('bar', 'ZendTest\\Di\\TestAsset\\ConstructorInjection\\F', array('params' => array('p' => 'vbar'))); $pref = $di->get('ZendTest\\Di\\TestAsset\\ConstructorInjection\\B'); $bFoo = $di->get('ZendTest\\Di\\TestAsset\\ConstructorInjection\\B', array('a' => 'foo')); $bBar = $di->get('ZendTest\\Di\\TestAsset\\ConstructorInjection\\B', array('a' => 'bar')); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\ConstructorInjection\\E', $pref->a); $this->assertNotSame($pref->a, $bFoo->a); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\ConstructorInjection\\F', $bFoo->a); $this->assertInstanceOf('ZendTest\\Di\\TestAsset\\ConstructorInjection\\F', $bBar->a); $this->assertEquals('vfoo', $bFoo->a->params['p']); $this->assertEquals('vbar', $bBar->a->params['p']); }
/** * Is command exist * * @param string $commandClass Command class * * @return bool */ protected function _isCommandExist($commandClass) { return in_array($commandClass, $this->_di->instanceManager()->getClasses()); }
/** * @param Di $di * @param ContainerInterface $container * @param null|DiInstanceManagerProxy $diImProxy */ public function __construct(Di $di, ContainerInterface $container, DiInstanceManagerProxy $diInstanceManagerProxy = null) { $this->di = $di; $this->container = $container; $this->diInstanceManagerProxy = $diInstanceManagerProxy ?: new DiInstanceManagerProxy($di->instanceManager(), $container); }