/**
* Create classes from array
*
* @param array $builderData
* @return void
*/
public function createClassesFromArray(array $builderData)
{
foreach ($builderData as $className => $classInfo) {
$class = new Builder\PhpClass();
$class->setName($className);
foreach ($classInfo as $type => $typeData) {
switch (strtolower($type)) {
case 'supertypes':
foreach ($typeData as $superType) {
$class->addSuperType($superType);
}
break;
case 'instantiator':
$class->setInstantiator($typeData);
break;
case 'methods':
case 'method':
foreach ($typeData as $injectionMethodName => $injectionMethodData) {
$injectionMethod = new Builder\InjectionMethod();
$injectionMethod->setName($injectionMethodName);
foreach ($injectionMethodData as $parameterName => $parameterType) {
$parameterType = $parameterType ?: null;
// force empty string to null
$injectionMethod->addParameter($parameterName, $parameterType);
}
$class->addInjectionMethod($injectionMethod);
}
break;
}
}
$this->addClass($class);
}
}
public function testBuilderCanBuildClassWithMethods()
{
$class = new Builder\PhpClass();
$class->setName('Foo');
$class->addSuperType('Parent');
$injectionMethod = new Builder\InjectionMethod();
$injectionMethod->setName('injectBar');
$injectionMethod->addParameter('bar', 'Bar');
$class->addInjectionMethod($injectionMethod);
$definition = new BuilderDefinition();
$definition->addClass($class);
$this->assertTrue($definition->hasClass('Foo'));
$this->assertEquals('__construct', $definition->getInstantiator('Foo'));
$this->assertContains('Parent', $definition->getClassSupertypes('Foo'));
$this->assertTrue($definition->hasMethods('Foo'));
$this->assertTrue($definition->hasMethod('Foo', 'injectBar'));
$this->assertContains('injectBar', $definition->getMethods('Foo'));
$this->assertEquals(array('Foo::injectBar:0' => array('bar', 'Bar', true, null)), $definition->getMethodParameters('Foo', 'injectBar'));
}
/**
* @param string $method
* @param mixed|bool|null $isRequired
* @return self
*/
public function addMethod($method, $isRequired = null)
{
if ($isRequired === null) {
if ($method === '__construct') {
$methodRequirementType = Di::METHOD_IS_CONSTRUCTOR;
}
$methodRequirementType = Di::METHOD_IS_OPTIONAL;
} else {
$methodRequirementType = InjectionMethod::detectMethodRequirement($isRequired);
}
$this->methods[$method] = $methodRequirementType;
return $this;
}
/**
* @param array $dataArray
*/
public function __construct(array $dataArray)
{
foreach ($dataArray as $class => $value) {
// force lower names
$dataArray[$class] = array_change_key_case($dataArray[$class], CASE_LOWER);
}
foreach ($dataArray as $class => $definition) {
if (isset($definition['methods']) && is_array($definition['methods'])) {
foreach ($definition['methods'] as $type => $requirement) {
if (!is_int($requirement)) {
$dataArray[$class]['methods'][$type] = InjectionMethod::detectMethodRequirement($requirement);
}
}
}
}
$this->dataArray = $dataArray;
}
/**
* @group nullargs
*/
public function testNullArgumentsResultInEmptyMethodParameterList()
{
$this->markTestIncomplete('Null arguments are currently unsupported');
$opt = new Builder\PhpClass();
$opt->setName('ZendTest\Di\TestAsset\OptionalArg');
$optCtor = new Builder\InjectionMethod();
$optCtor->setName('__construct')
->addParameter('param', null);
$optInject = new Builder\InjectionMethod();
$optInject->setName('inject')
->addParameter('param1', null)
->addParameter('param2', null);
$opt->addInjectionMethod($optCtor)
->addInjectionMethod($optInject);
$def = new Definition();
$def->addClass($opt);
$this->di->setDefinition($def);
$cfg = new Configuration(array(
'instance' => array(
'alias' => array('optional' => 'ZendTest\Di\TestAsset\OptionalArg'),
),
'properties' => array(
'ZendTest\Di\TestAsset\OptionalArg' => array(
'param' => null,
'param1' => null,
'param2' => null,
),
),
));
$cfg->configure($this->di);
$builder = new ContainerGenerator($this->di);
$builder->setContainerClass('Container');
$codeGen = $builder->getCodeGenerator();
$classBody = $codeGen->generate();
$this->assertNotContains('NULL)', $classBody, $classBody);
}
