interface/modules/zend_modules/library/Zend/Di/Config.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Di;
  11
  12 use Traversable;
  13 use Zend\Di\Definition\ArrayDefinition;
  14 use Zend\Di\Definition\RuntimeDefinition;
  15 use Zend\Stdlib\ArrayUtils;
  16
  17 /**
  18  * Configures Di instances
  19  */
  20 class Config
  21 {
  22     /**
  23      * @var array
  24      */
  25     protected $data = array();
  26
  27     /**
  28      * Constructor
  29      *
  30      * @param  array|Traversable                  $options
  31      * @throws Exception\InvalidArgumentException
  32      */
  33     public function __construct($options)
  34     {
  35         if ($options instanceof Traversable) {
  36             $options = ArrayUtils::iteratorToArray($options);
  37         }
  38
  39         if (!is_array($options)) {
  40             throw new Exception\InvalidArgumentException(
  41                 'Config data must be of type Traversable or an array'
  42             );
  43         }
  44         $this->data = $options;
  45     }
  46
  47     /**
  48      * Configure
  49      *
  50      * @param  Di   $di
  51      * @return void
  52      */
  53     public function configure(Di $di)
  54     {
  55         if (isset($this->data['definition'])) {
  56             $this->configureDefinition($di, $this->data['definition']);
  57         }
  58         if (isset($this->data['instance'])) {
  59             $this->configureInstance($di, $this->data['instance']);
  60         }
  61     }
  62
  63     /**
  64      * @param Di    $di
  65      * @param array $definition
  66      */
  67     public function configureDefinition(Di $di, $definition)
  68     {
  69         foreach ($definition as $definitionType => $definitionData) {
  70             switch ($definitionType) {
  71                 case 'compiler':
  72                     foreach ($definitionData as $filename) {
  73                         if (is_readable($filename)) {
  74                             $di->definitions()->addDefinition(new ArrayDefinition(include $filename), false);
  75                         }
  76                     }
  77                     break;
  78                 case 'runtime':
  79                     if (isset($definitionData['enabled']) && !$definitionData['enabled']) {
  80                         // Remove runtime from definition list if not enabled
  81                         $definitions = array();
  82                         foreach ($di->definitions() as $definition) {
  83                             if (!$definition instanceof RuntimeDefinition) {
  84                                 $definitions[] = $definition;
  85                             }
  86                         }
  87                         $definitionList = new DefinitionList($definitions);
  88                         $di->setDefinitionList($definitionList);
  89                     } elseif (isset($definitionData['use_annotations']) && $definitionData['use_annotations']) {
  90                         /* @var $runtimeDefinition Definition\RuntimeDefinition */
  91                         $runtimeDefinition = $di
  92                             ->definitions()
  93                             ->getDefinitionByType('\Zend\Di\Definition\RuntimeDefinition');
  94                         $runtimeDefinition->getIntrospectionStrategy()->setUseAnnotations(true);
  95                     }
  96                     break;
  97                 case 'class':
  98                     foreach ($definitionData as $className => $classData) {
  99                         $classDefinitions = $di->definitions()->getDefinitionsByType('Zend\Di\Definition\ClassDefinition');
 100                         foreach ($classDefinitions as $classDefinition) {
 101                             if (!$classDefinition->hasClass($className)) {
 102                                 unset($classDefinition);
 103                             }
 104                         }
 105                         if (!isset($classDefinition)) {
 106                             $classDefinition = new Definition\ClassDefinition($className);
 107                             $di->definitions()->addDefinition($classDefinition, false);
 108                         }
 109                         foreach ($classData as $classDefKey => $classDefData) {
 110                             switch ($classDefKey) {
 111                                 case 'instantiator':
 112                                     $classDefinition->setInstantiator($classDefData);
 113                                     break;
 114                                 case 'supertypes':
 115                                     $classDefinition->setSupertypes($classDefData);
 116                                     break;
 117                                 case 'methods':
 118                                 case 'method':
 119                                     foreach ($classDefData as $methodName => $methodInfo) {
 120                                         if (isset($methodInfo['required'])) {
 121                                             $classDefinition->addMethod($methodName, $methodInfo['required']);
 122                                             unset($methodInfo['required']);
 123                                         }
 124                                         foreach ($methodInfo as $paramName => $paramInfo) {
 125                                             $classDefinition->addMethodParameter($methodName, $paramName, $paramInfo);
 126                                         }
 127                                     }
 128                                     break;
 129                                 default:
 130                                     $methodName = $classDefKey;
 131                                     $methodInfo = $classDefData;
 132                                     if (isset($classDefData['required'])) {
 133                                         $classDefinition->addMethod($methodName, $methodInfo['required']);
 134                                         unset($methodInfo['required']);
 135                                     }
 136                                     foreach ($methodInfo as $paramName => $paramInfo) {
 137                                         $classDefinition->addMethodParameter($methodName, $paramName, $paramInfo);
 138                                     }
 139                             }
 140                         }
 141                     }
 142             }
 143         }
 144     }
 145
 146     /**
 147      * Configures a given Di instance
 148      *
 149      * @param Di $di
 150      * @param $instanceData
 151      */
 152     public function configureInstance(Di $di, $instanceData)
 153     {
 154         $im = $di->instanceManager();
 155
 156         foreach ($instanceData as $target => $data) {
 157             switch (strtolower($target)) {
 158                 case 'aliases':
 159                 case 'alias':
 160                     foreach ($data as $n => $v) {
 161                         $im->addAlias($n, $v);
 162                     }
 163                     break;
 164                 case 'preferences':
 165                 case 'preference':
 166                     foreach ($data as $n => $v) {
 167                         if (is_array($v)) {
 168                             foreach ($v as $v2) {
 169                                 $im->addTypePreference($n, $v2);
 170                             }
 171                         } else {
 172                             $im->addTypePreference($n, $v);
 173                         }
 174                     }
 175                     break;
 176                 default:
 177                     foreach ($data as $n => $v) {
 178                         switch ($n) {
 179                             case 'parameters':
 180                             case 'parameter':
 181                                 $im->setParameters($target, $v);
 182                                 break;
 183                             case 'injections':
 184                             case 'injection':
 185                                 $im->setInjections($target, $v);
 186                                 break;
 187                             case 'shared':
 188                             case 'share':
 189                                 $im->setShared($target, $v);
 190                                 break;
 191                         }
 192                     }
 193             }
 194         }
 195     }
 196 }