Merge branch 'master' of git://github.com/zendframework/zf2 into cach…

…e_interfaces

.travis/run-tests.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-travisdir=$(dirname $(readlink /proc/$$/fd/255))
+travisdir=$(dirname "$0")
 testdir="$travisdir/../tests"
 testedcomponents=(`cat "$travisdir/tested-components"`)
 result=0

.travis/skipped-components

@@ -1,5 +1,6 @@
 Zend/Amf
 Zend/Date
+Zend/Dojo
 Zend/Queue
 Zend/Service
 Zend/Test

.travis/tested-components

@@ -22,17 +22,19 @@ Zend/Form
 Zend/GData
 Zend/Http
 Zend/InfoCard
+Zend/InputFilter
 Zend/Json
 Zend/Ldap
 Zend/Loader
 Zend/Locale
 Zend/Log
 Zend/Mail
 Zend/Markup
+Zend/Math
 Zend/Measure
 Zend/Memory
 Zend/Mime
-Zend/Module
+Zend/ModuleManager
 Zend/Mvc
 Zend/Navigation
 Zend/OAuth

src/Configuration.php

@@ -48,10 +48,28 @@ public function configureDefinition(Di $di, $definition)
         foreach ($definition as $definitionType => $definitionData) {
             switch ($definitionType) {
                 case 'compiler':
-                    // @todo
+                    foreach ($definitionData as $filename) {
+                        if (is_readable($filename)) {
+                            $di->definitions()->addDefinition(new \Zend\Di\Definition\ArrayDefinition(include $filename), false);
+                        }
+                    }
                     break;
                 case 'runtime':
-                    // @todo
+                    if (isset($definitionData['enabled']) && !$definitionData['enabled']) {
+                        // Remove runtime from definition list if not enabled
+                        $definitions = array();
+                        foreach ($di->definitions() as $definition) {
+                            if (!$definition instanceof \Zend\Di\Definition\RuntimeDefinition) {
+                                $definitions[] = $definition;
+                            }
+                        }
+                        $definitions = new DefinitionList($definitions);
+                        $di->setDefinitionList($definitions);
+                    } elseif (isset($definitionData['use_annotations']) && $definitionData['use_annotations']) {
+                        $di->definitions()->getDefinitionByType('\Zend\Di\Definition\RuntimeDefinition')
+                            ->getIntrospectionStrategy()
+                            ->setUseAnnotations(true);
+                    }
                     break;
                 case 'class':
                     foreach ($definitionData as $className => $classData) {

src/Di.php

@@ -208,7 +208,7 @@ public function newInstance($name, array $params = array(), $isShared = true)
             }
         }
 
-        $this->handleInjectDependencies($instance, $class, $injectionMethods, $supertypeInjectionMethods, $params, $alias);
+        $this->handleInjectDependencies($instance, $injectionMethods, $supertypeInjectionMethods, $params, $class, $alias, $name);
 
         array_pop($this->instanceContext);
         return $instance;
@@ -236,13 +236,12 @@ public function injectDependencies($instance, array $params = array())
                 $superTypeInjectionMethods[$interface] = $definitions->getMethods($interface);
             }
         }
-        $this->handleInjectDependencies($instance, null, $injectionMethods, $superTypeInjectionMethods, $params, null);
+        $this->handleInjectDependencies($instance, $injectionMethods, $superTypeInjectionMethods, $params, $class, null, null);
     }
 
 
-    protected function handleInjectDependencies($instance, $name, $injectionMethods, $supertypeInjectionMethods, $params, $alias)
+    protected function handleInjectDependencies($instance, $injectionMethods, $supertypeInjectionMethods, $params, $instanceClass, $instanceAlias, $requestedName)
     {
-        $class = get_class($instance);
 
         // localize dependencies
         $definitions     = $this->definitions;
@@ -251,19 +250,19 @@ protected function handleInjectDependencies($instance, $name, $injectionMethods,
         if ($injectionMethods || $supertypeInjectionMethods) {
             foreach ($injectionMethods as $injectionMethod => $methodIsRequired) {
                 if ($injectionMethod !== '__construct'){
-                    $this->resolveAndCallInjectionMethodForInstance($instance, $injectionMethod, $params, $alias, $methodIsRequired, $class);
+                    $this->resolveAndCallInjectionMethodForInstance($instance, $injectionMethod, $params, $instanceAlias, $methodIsRequired, $instanceClass);
                 }
             }
             foreach ($supertypeInjectionMethods as $supertype => $supertypeInjectionMethod) {
                 foreach ($supertypeInjectionMethod as $injectionMethod => $methodIsRequired) {
                     if ($injectionMethod !== '__construct') {
-                        $this->resolveAndCallInjectionMethodForInstance($instance, $injectionMethod, $params, $alias, $methodIsRequired, $supertype);
+                        $this->resolveAndCallInjectionMethodForInstance($instance, $injectionMethod, $params, $instanceAlias, $methodIsRequired, $supertype);
                     }
                 }
             }
 
-            if ($name) {
-                $instanceConfiguration = $instanceManager->getConfiguration($name);
+            if ($requestedName) {
+                $instanceConfiguration = $instanceManager->getConfiguration($requestedName);
 
                 if ($instanceConfiguration['injections']) {
                     $objectsToInject = $methodsToCall = array();
@@ -290,11 +289,11 @@ protected function handleInjectDependencies($instance, $name, $injectionMethods,
                     if ($objectsToInject) {
                         foreach ($objectsToInject as $objectToInject) {
                             foreach ($injectionMethods as $injectionMethod => $methodIsRequired) {
-                                $methodParams = $definitions->getMethodParameters($class, $injectionMethod);
+                                $methodParams = $definitions->getMethodParameters($instanceClass, $injectionMethod);
                                 if ($methodParams) {
                                     foreach ($methodParams as $methodParam) {
                                         if (get_class($objectToInject) == $methodParam[1] || $this->isSubclassOf(get_class($objectToInject), $methodParam[1])) {
-                                            $this->resolveAndCallInjectionMethodForInstance($instance, $injectionMethod, array($methodParam[0] => $objectToInject), $alias, true, get_class($instance));
+                                            $this->resolveAndCallInjectionMethodForInstance($instance, $injectionMethod, array($methodParam[0] => $objectToInject), $instanceAlias, true, get_class($instance));
                                             continue 3;
                                         }
                                     }
@@ -304,7 +303,7 @@ protected function handleInjectDependencies($instance, $name, $injectionMethods,
                     }
                     if ($methodsToCall) {
                         foreach ($methodsToCall as $methodInfo) {
-                            $this->resolveAndCallInjectionMethodForInstance($instance, $methodInfo['method'], $methodInfo['args'], $alias, true, get_class($instance));
+                            $this->resolveAndCallInjectionMethodForInstance($instance, $methodInfo['method'], $methodInfo['args'], $instanceAlias, true, get_class($instance));
                         }
                     }
                 }

src/ServiceLocator/Generator.php

@@ -241,9 +241,9 @@ public function getCodeGenerator($filename = null)
         $container = new CodeGen\PhpClass();
         $container->setName($this->containerClass)
                   ->setExtendedClass('ServiceLocator')
-                  ->setMethod($get)
-                  ->setMethods($getters)
-                  ->setMethods($aliasMethods);
+                  ->addMethodFromGenerator($get)
+                  ->addMethods($getters)
+                  ->addMethods($aliasMethods);
 
         // Create PHP file code generation object
         $classFile = new CodeGen\PhpFile();

test/ConfigurationTest.php

@@ -72,7 +72,51 @@ public function testConfigurationCanConfigureBuilderDefinitionFromIni()
             );
 
     }
-
 
-
+    public function testConfigurationCanConfigureRuntimeDefinitionDefaultFromIni()
+    {
+        $ini = ConfigFactory::fromFile(__DIR__ . '/_files/sample.ini', true)->get('section-c');
+        $config = new Configuration($ini->di);
+        $di = new Di();
+        $di->configure($config);
+        $definition = $di->definitions()->getDefinitionByType('Zend\Di\Definition\RuntimeDefinition');
+        $this->assertInstanceOf('Zend\Di\Definition\RuntimeDefinition', $definition);
+        $this->assertFalse($definition->getIntrospectionStrategy()->getUseAnnotations());
+    }
+
+    public function testConfigurationCanConfigureRuntimeDefinitionDisabledFromIni()
+    {
+        $ini = ConfigFactory::fromFile(__DIR__ . '/_files/sample.ini', true)->get('section-d');
+        $config = new Configuration($ini->di);
+        $di = new Di();
+        $di->configure($config);
+        $definition = $di->definitions()->getDefinitionByType('Zend\Di\Definition\RuntimeDefinition');
+        $this->assertFalse($definition);
+    }
+
+    public function testConfigurationCanConfigureRuntimeDefinitionUseAnnotationFromIni()
+    {
+        $ini = ConfigFactory::fromFile(__DIR__ . '/_files/sample.ini', true)->get('section-e');
+        $config = new Configuration($ini->di);
+        $di = new Di();
+        $di->configure($config);
+        $definition = $di->definitions()->getDefinitionByType('Zend\Di\Definition\RuntimeDefinition');
+        $this->assertTrue($definition->getIntrospectionStrategy()->getUseAnnotations());
+    }
+
+    public function testConfigurationCanConfigureCompiledDefinition()
+    {
+        $config = ConfigFactory::fromFile(__DIR__ . '/_files/sample.php', true);
+        $config = new Configuration($config->di);
+        $di = new Di();
+        $di->configure($config);
+        $definition = $di->definitions()->getDefinitionByType('Zend\Di\Definition\ArrayDefinition');
+        $this->assertInstanceOf('Zend\Di\Definition\ArrayDefinition', $definition);
+        $this->assertTrue($di->definitions()->hasClass('My\DbAdapter'));
+        $this->assertTrue($di->definitions()->hasClass('My\EntityA'));
+        $this->assertTrue($di->definitions()->hasClass('My\Mapper'));
+        $this->assertTrue($di->definitions()->hasClass('My\RepositoryA'));
+        $this->assertTrue($di->definitions()->hasClass('My\RepositoryB'));
+        $this->assertFalse($di->definitions()->hasClass('My\Foo'));
+    }
 }