interface/modules/zend_modules/library/Zend/ModuleManager/ModuleManager.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\ModuleManager;
  11
  12 use Traversable;
  13 use Zend\EventManager\EventManager;
  14 use Zend\EventManager\EventManagerInterface;
  15
  16 /**
  17  * Module manager
  18  */
  19 class ModuleManager implements ModuleManagerInterface
  20 {
  21     /**
  22      * @var array An array of Module classes of loaded modules
  23      */
  24     protected $loadedModules = array();
  25
  26     /**
  27      * @var EventManagerInterface
  28      */
  29     protected $events;
  30
  31     /**
  32      * @var ModuleEvent
  33      */
  34     protected $event;
  35
  36     /**
  37      * @var bool
  38      */
  39     protected $loadFinished;
  40
  41     /**
  42      * modules
  43      *
  44      * @var array|Traversable
  45      */
  46     protected $modules = array();
  47
  48     /**
  49      * True if modules have already been loaded
  50      *
  51      * @var bool
  52      */
  53     protected $modulesAreLoaded = false;
  54
  55     /**
  56      * Constructor
  57      *
  58      * @param  array|Traversable $modules
  59      * @param  EventManagerInterface $eventManager
  60      */
  61     public function __construct($modules, EventManagerInterface $eventManager = null)
  62     {
  63         $this->setModules($modules);
  64         if ($eventManager instanceof EventManagerInterface) {
  65             $this->setEventManager($eventManager);
  66         }
  67     }
  68
  69     /**
  70      * Handle the loadModules event
  71      *
  72      * @return void
  73      */
  74     public function onLoadModules()
  75     {
  76         if (true === $this->modulesAreLoaded) {
  77             return $this;
  78         }
  79
  80         foreach ($this->getModules() as $moduleName => $module) {
  81             if (is_object($module)) {
  82                 if (!is_string($moduleName)) {
  83                     throw new Exception\RuntimeException(sprintf(
  84                         'Module (%s) must have a key identifier.',
  85                         get_class($module)
  86                     ));
  87                 }
  88                 $module = array($moduleName => $module);
  89             }
  90             $this->loadModule($module);
  91         }
  92
  93         $this->modulesAreLoaded = true;
  94     }
  95
  96     /**
  97      * Load the provided modules.
  98      *
  99      * @triggers loadModules
 100      * @triggers loadModules.post
 101      * @return   ModuleManager
 102      */
 103     public function loadModules()
 104     {
 105         if (true === $this->modulesAreLoaded) {
 106             return $this;
 107         }
 108
 109         $this->getEventManager()->trigger(ModuleEvent::EVENT_LOAD_MODULES, $this, $this->getEvent());
 110
 111         /**
 112          * Having a dedicated .post event abstracts the complexity of priorities from the user.
 113          * Users can attach to the .post event and be sure that important
 114          * things like config merging are complete without having to worry if
 115          * they set a low enough priority.
 116          */
 117         $this->getEventManager()->trigger(ModuleEvent::EVENT_LOAD_MODULES_POST, $this, $this->getEvent());
 118
 119         return $this;
 120     }
 121
 122     /**
 123      * Load a specific module by name.
 124      *
 125      * @param  string|array               $module
 126      * @throws Exception\RuntimeException
 127      * @triggers loadModule.resolve
 128      * @triggers loadModule
 129      * @return mixed Module's Module class
 130      */
 131     public function loadModule($module)
 132     {
 133         $moduleName = $module;
 134         if (is_array($module)) {
 135             $moduleName = key($module);
 136             $module = current($module);
 137         }
 138
 139         if (isset($this->loadedModules[$moduleName])) {
 140             return $this->loadedModules[$moduleName];
 141         }
 142
 143         $event = ($this->loadFinished === false) ? clone $this->getEvent() : $this->getEvent();
 144         $event->setModuleName($moduleName);
 145
 146         $this->loadFinished = false;
 147
 148         if (!is_object($module)) {
 149             $module = $this->loadModuleByName($event);
 150         }
 151         $event->setModule($module);
 152
 153         $this->loadedModules[$moduleName] = $module;
 154         $this->getEventManager()->trigger(ModuleEvent::EVENT_LOAD_MODULE, $this, $event);
 155
 156         $this->loadFinished = true;
 157
 158         return $module;
 159     }
 160
 161     /**
 162      * Load a module with the name
 163      * @param  Zend\EventManager\EventInterface $event
 164      * @return mixed                            module instance
 165      * @throws Exception\RuntimeException
 166      */
 167     protected function loadModuleByName($event)
 168     {
 169         $result = $this->getEventManager()->trigger(ModuleEvent::EVENT_LOAD_MODULE_RESOLVE, $this, $event, function ($r) {
 170             return (is_object($r));
 171         });
 172
 173         $module = $result->last();
 174         if (!is_object($module)) {
 175             throw new Exception\RuntimeException(sprintf(
 176                 'Module (%s) could not be initialized.',
 177                 $event->getModuleName()
 178             ));
 179         }
 180
 181         return $module;
 182     }
 183
 184     /**
 185      * Get an array of the loaded modules.
 186      *
 187      * @param  bool  $loadModules If true, load modules if they're not already
 188      * @return array An array of Module objects, keyed by module name
 189      */
 190     public function getLoadedModules($loadModules = false)
 191     {
 192         if (true === $loadModules) {
 193             $this->loadModules();
 194         }
 195
 196         return $this->loadedModules;
 197     }
 198
 199     /**
 200      * Get an instance of a module class by the module name
 201      *
 202      * @param  string $moduleName
 203      * @return mixed
 204      */
 205     public function getModule($moduleName)
 206     {
 207         if (!isset($this->loadedModules[$moduleName])) {
 208             return null;
 209         }
 210         return $this->loadedModules[$moduleName];
 211     }
 212
 213     /**
 214      * Get the array of module names that this manager should load.
 215      *
 216      * @return array
 217      */
 218     public function getModules()
 219     {
 220         return $this->modules;
 221     }
 222
 223     /**
 224      * Set an array or Traversable of module names that this module manager should load.
 225      *
 226      * @param  mixed $modules array or Traversable of module names
 227      * @throws Exception\InvalidArgumentException
 228      * @return ModuleManager
 229      */
 230     public function setModules($modules)
 231     {
 232         if (is_array($modules) || $modules instanceof Traversable) {
 233             $this->modules = $modules;
 234         } else {
 235             throw new Exception\InvalidArgumentException(sprintf(
 236                 'Parameter to %s\'s %s method must be an array or implement the Traversable interface',
 237                 __CLASS__, __METHOD__
 238             ));
 239         }
 240         return $this;
 241     }
 242
 243     /**
 244      * Get the module event
 245      *
 246      * @return ModuleEvent
 247      */
 248     public function getEvent()
 249     {
 250         if (!$this->event instanceof ModuleEvent) {
 251             $this->setEvent(new ModuleEvent);
 252         }
 253         return $this->event;
 254     }
 255
 256     /**
 257      * Set the module event
 258      *
 259      * @param  ModuleEvent $event
 260      * @return ModuleManager
 261      */
 262     public function setEvent(ModuleEvent $event)
 263     {
 264         $this->event = $event;
 265         return $this;
 266     }
 267
 268     /**
 269      * Set the event manager instance used by this module manager.
 270      *
 271      * @param  EventManagerInterface $events
 272      * @return ModuleManager
 273      */
 274     public function setEventManager(EventManagerInterface $events)
 275     {
 276         $events->setIdentifiers(array(
 277             __CLASS__,
 278             get_class($this),
 279             'module_manager',
 280         ));
 281         $this->events = $events;
 282         $this->attachDefaultListeners();
 283         return $this;
 284     }
 285
 286     /**
 287      * Retrieve the event manager
 288      *
 289      * Lazy-loads an EventManager instance if none registered.
 290      *
 291      * @return EventManagerInterface
 292      */
 293     public function getEventManager()
 294     {
 295         if (!$this->events instanceof EventManagerInterface) {
 296             $this->setEventManager(new EventManager());
 297         }
 298         return $this->events;
 299     }
 300
 301     /**
 302      * Register the default event listeners
 303      *
 304      * @return ModuleManager
 305      */
 306     protected function attachDefaultListeners()
 307     {
 308         $events = $this->getEventManager();
 309         $events->attach(ModuleEvent::EVENT_LOAD_MODULES, array($this, 'onLoadModules'));
 310     }
 311 }