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