interface/modules/zend_modules/library/Zend/ModuleManager/Listener/ListenerOptions.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\Listener;
  11
  12 use Traversable;
  13 use Zend\Stdlib\AbstractOptions;
  14
  15 /**
  16  * Listener options
  17  */
  18 class ListenerOptions extends AbstractOptions
  19 {
  20     /**
  21      * @var array
  22      */
  23     protected $modulePaths = array();
  24
  25     /**
  26      * @var array
  27      */
  28     protected $configGlobPaths = array();
  29
  30     /**
  31      * @var array
  32      */
  33     protected $configStaticPaths = array();
  34
  35     /**
  36      * @var array
  37      */
  38     protected $extraConfig = array();
  39
  40     /**
  41      * @var bool
  42      */
  43     protected $configCacheEnabled = false;
  44
  45     /**
  46      * @var string
  47      */
  48     protected $configCacheKey;
  49
  50     /**
  51      * @var string
  52      */
  53     protected $cacheDir;
  54
  55     /**
  56      * @var bool
  57      */
  58     protected $checkDependencies = true;
  59
  60     /**
  61      * @var string
  62      */
  63     protected $moduleMapCacheEnabled = false;
  64
  65     /**
  66      * @var string
  67      */
  68     protected $moduleMapCacheKey;
  69
  70     /**
  71      * Get an array of paths where modules reside
  72      *
  73      * @return array
  74      */
  75     public function getModulePaths()
  76     {
  77         return $this->modulePaths;
  78     }
  79
  80     /**
  81      * Set an array of paths where modules reside
  82      *
  83      * @param  array|Traversable $modulePaths
  84      * @throws Exception\InvalidArgumentException
  85      * @return ListenerOptions Provides fluent interface
  86      */
  87     public function setModulePaths($modulePaths)
  88     {
  89         if (!is_array($modulePaths) && !$modulePaths instanceof Traversable) {
  90             throw new Exception\InvalidArgumentException(
  91                 sprintf('Argument passed to %s::%s() must be an array, '
  92                 . 'implement the Traversable interface, or be an '
  93                 . 'instance of Zend\Config\Config. %s given.',
  94                 __CLASS__, __METHOD__, gettype($modulePaths))
  95             );
  96         }
  97
  98         $this->modulePaths = $modulePaths;
  99         return $this;
 100     }
 101
 102     /**
 103      * Get the glob patterns to load additional config files
 104      *
 105      * @return array
 106      */
 107     public function getConfigGlobPaths()
 108     {
 109         return $this->configGlobPaths;
 110     }
 111
 112     /**
 113      * Get the static paths to load additional config files
 114      *
 115      * @return array
 116      */
 117     public function getConfigStaticPaths()
 118     {
 119         return $this->configStaticPaths;
 120     }
 121
 122     /**
 123      * Set the glob patterns to use for loading additional config files
 124      *
 125      * @param array|Traversable $configGlobPaths
 126      * @throws Exception\InvalidArgumentException
 127      * @return ListenerOptions Provides fluent interface
 128      */
 129     public function setConfigGlobPaths($configGlobPaths)
 130     {
 131         if (!is_array($configGlobPaths) && !$configGlobPaths instanceof Traversable) {
 132             throw new Exception\InvalidArgumentException(
 133                 sprintf('Argument passed to %s::%s() must be an array, '
 134                 . 'implement the Traversable interface, or be an '
 135                 . 'instance of Zend\Config\Config. %s given.',
 136                 __CLASS__, __METHOD__, gettype($configGlobPaths))
 137             );
 138         }
 139
 140         $this->configGlobPaths = $configGlobPaths;
 141         return $this;
 142     }
 143
 144     /**
 145      * Set the static paths to use for loading additional config files
 146      *
 147      * @param array|Traversable $configStaticPaths
 148      * @throws Exception\InvalidArgumentException
 149      * @return ListenerOptions Provides fluent interface
 150      */
 151     public function setConfigStaticPaths($configStaticPaths)
 152     {
 153         if (!is_array($configStaticPaths) && !$configStaticPaths instanceof Traversable) {
 154             throw new Exception\InvalidArgumentException(
 155                 sprintf('Argument passed to %s::%s() must be an array, '
 156                 . 'implement the Traversable interface, or be an '
 157                 . 'instance of Zend\Config\Config. %s given.',
 158                 __CLASS__, __METHOD__, gettype($configStaticPaths))
 159             );
 160         }
 161
 162         $this->configStaticPaths = $configStaticPaths;
 163         return $this;
 164     }
 165
 166     /**
 167      * Get any extra config to merge in.
 168      *
 169      * @return array|Traversable
 170      */
 171     public function getExtraConfig()
 172     {
 173         return $this->extraConfig;
 174     }
 175
 176     /**
 177      * Add some extra config array to the main config. This is mainly useful
 178      * for unit testing purposes.
 179      *
 180      * @param array|Traversable $extraConfig
 181      * @throws Exception\InvalidArgumentException
 182      * @return ListenerOptions Provides fluent interface
 183      */
 184     public function setExtraConfig($extraConfig)
 185     {
 186         if (!is_array($extraConfig) && !$extraConfig instanceof Traversable) {
 187             throw new Exception\InvalidArgumentException(
 188                 sprintf('Argument passed to %s::%s() must be an array, '
 189                 . 'implement the Traversable interface, or be an '
 190                 . 'instance of Zend\Config\Config. %s given.',
 191                 __CLASS__, __METHOD__, gettype($extraConfig))
 192             );
 193         }
 194
 195         $this->extraConfig = $extraConfig;
 196         return $this;
 197     }
 198
 199     /**
 200      * Check if the config cache is enabled
 201      *
 202      * @return bool
 203      */
 204     public function getConfigCacheEnabled()
 205     {
 206         return $this->configCacheEnabled;
 207     }
 208
 209     /**
 210      * Set if the config cache should be enabled or not
 211      *
 212      * @param  bool $enabled
 213      * @return ListenerOptions
 214      */
 215     public function setConfigCacheEnabled($enabled)
 216     {
 217         $this->configCacheEnabled = (bool) $enabled;
 218         return $this;
 219     }
 220
 221     /**
 222      * Get key used to create the cache file name
 223      *
 224      * @return string
 225      */
 226     public function getConfigCacheKey()
 227     {
 228         return (string) $this->configCacheKey;
 229     }
 230
 231     /**
 232      * Set key used to create the cache file name
 233      *
 234      * @param  string $configCacheKey the value to be set
 235      * @return ListenerOptions
 236      */
 237     public function setConfigCacheKey($configCacheKey)
 238     {
 239         $this->configCacheKey = $configCacheKey;
 240         return $this;
 241     }
 242
 243     /**
 244      * Get the path to the config cache
 245      *
 246      * Should this be an option, or should the dir option include the
 247      * filename, or should it simply remain hard-coded? Thoughts?
 248      *
 249      * @return string
 250      */
 251     public function getConfigCacheFile()
 252     {
 253         return $this->getCacheDir() . '/module-config-cache.' . $this->getConfigCacheKey().'.php';
 254     }
 255
 256     /**
 257      * Get the path where cache file(s) are stored
 258      *
 259      * @return string
 260      */
 261     public function getCacheDir()
 262     {
 263         return $this->cacheDir;
 264     }
 265
 266     /**
 267      * Set the path where cache files can be stored
 268      *
 269      * @param  string $cacheDir the value to be set
 270      * @return ListenerOptions
 271      */
 272     public function setCacheDir($cacheDir)
 273     {
 274         if (null === $cacheDir) {
 275             $this->cacheDir = $cacheDir;
 276         } else {
 277             $this->cacheDir = static::normalizePath($cacheDir);
 278         }
 279         return $this;
 280     }
 281
 282     /**
 283      * Check if the module class map cache is enabled
 284      *
 285      * @return bool
 286      */
 287     public function getModuleMapCacheEnabled()
 288     {
 289         return $this->moduleMapCacheEnabled;
 290     }
 291
 292     /**
 293      * Set if the module class map cache should be enabled or not
 294      *
 295      * @param  bool $enabled
 296      * @return ListenerOptions
 297      */
 298     public function setModuleMapCacheEnabled($enabled)
 299     {
 300         $this->moduleMapCacheEnabled = (bool) $enabled;
 301         return $this;
 302     }
 303
 304     /**
 305      * Get key used to create the cache file name
 306      *
 307      * @return string
 308      */
 309     public function getModuleMapCacheKey()
 310     {
 311         return (string) $this->moduleMapCacheKey;
 312     }
 313
 314     /**
 315      * Set key used to create the cache file name
 316      *
 317      * @param  string $moduleMapCacheKey the value to be set
 318      * @return ListenerOptions
 319      */
 320     public function setModuleMapCacheKey($moduleMapCacheKey)
 321     {
 322         $this->moduleMapCacheKey = $moduleMapCacheKey;
 323         return $this;
 324     }
 325
 326     /**
 327      * Get the path to the module class map cache
 328      *
 329      * @return string
 330      */
 331     public function getModuleMapCacheFile()
 332     {
 333         return $this->getCacheDir() . '/module-classmap-cache.'.$this->getModuleMapCacheKey().'.php';
 334     }
 335
 336     /**
 337      * Set whether to check dependencies during module loading or not
 338      *
 339      * @return string
 340      */
 341     public function getCheckDependencies()
 342     {
 343         return $this->checkDependencies;
 344     }
 345
 346     /**
 347      * Set whether to check dependencies during module loading or not
 348      *
 349      * @param  bool $checkDependencies the value to be set
 350      *
 351      * @return ListenerOptions
 352      */
 353     public function setCheckDependencies($checkDependencies)
 354     {
 355         $this->checkDependencies = (bool) $checkDependencies;
 356
 357         return $this;
 358     }
 359
 360     /**
 361      * Normalize a path for insertion in the stack
 362      *
 363      * @param  string $path
 364      * @return string
 365      */
 366     public static function normalizePath($path)
 367     {
 368         $path = rtrim($path, '/');
 369         $path = rtrim($path, '\\');
 370         return $path;
 371     }
 372 }