Current file: htdocs/app/Mage.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
0.00%0.00%
0.00% 0 / 1
35.00%35.00%
35.00% 14 / 40 CRAP
23.05%23.05%
23.05% 65 / 282
 
Mage
0.00%0.00%
0.00% 0 / 1
0.00%0.00%
0.00% 0 / 1
23.05%23.05%
23.05% 65 / 282
 getVersion()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2
Functions
  
   
35.90%35.90%
35.90% 14 / 39
100.00%100.00%
100.00% 0 / 0
 getVersionInfo()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 7
 reset()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 8
 register($key, $value, $graceful = false)
0.00%0.00%
0.00% 0 / 1 4.68
42.86%42.86%
42.86% 3 / 7
 unregister($key)
0.00%0.00%
0.00% 0 / 1 20
0.00%0.00%
0.00% 0 / 7
 registry($key)
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 3 / 3
 setRoot($appRoot = '')
0.00%0.00%
0.00% 0 / 1 30
0.00%0.00%
0.00% 0 / 11
 getRoot()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 getEvents()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 objects($key = null)
100.00%100.00%
100.00% 1 / 1 3
100.00%100.00%
100.00% 6 / 6
 getBaseDir($type = 'base')
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 getModuleDir($type, $moduleName)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 getStoreConfig($path, $store = null)
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 getStoreConfigFlag($path, $store = null)
100.00%100.00%
100.00% 1 / 1 3
100.00%100.00%
100.00% 4 / 4
 getBaseUrl($type = Mage_Core_Model_Store::URL_TYPE_LINK, $secure = null)
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 getUrl($route = '', $params = array()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 getDesign()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 getConfig()
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 addObserver($eventName, $callback, $data = array()
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 6
 dispatchEvent($name, array $data = array()
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 4 / 4
 getModel($modelClass = '', $arguments = array()
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 getSingleton($modelClass='', array $arguments=array()
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 5 / 5
 getResourceModel($modelClass, $arguments = array()
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 getControllerInstance($class, $request, $response, array $invokeArgs = array()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 getResourceSingleton($modelClass = '', array $arguments = array()
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 5 / 5
 getBlockSingleton($type)
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 2
 helper($name)
100.00%100.00%
100.00% 1 / 1 3
100.00%100.00%
100.00% 9 / 9
 exception($module = 'Mage_Core', $message = '', $code = 0)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2
 throwException($message, $messageStorage = null)
0.00%0.00%
0.00% 0 / 1 12
0.00%0.00%
0.00% 0 / 4
 app($code = '', $type = 'store', $options = array()
0.00%0.00%
0.00% 0 / 1 4.19
18.18%18.18%
18.18% 2 / 11
 init($code = '', $type = 'store', $options = array()
0.00%0.00%
0.00% 0 / 1 30
0.00%0.00%
0.00% 0 / 17
 run($code = '', $type = 'store', $options=array()
0.00%0.00%
0.00% 0 / 1 72
0.00%0.00%
0.00% 0 / 29
 isInstalled($options = array()
0.00%0.00%
0.00% 0 / 1 42.72
10.00%10.00%
10.00% 2 / 20
 log($message, $level = null, $file = '', $forceLog = false)
0.00%0.00%
0.00% 0 / 1 81.08
39.47%39.47%
39.47% 15 / 38
 logException(Exception $e)
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 5
 setIsDeveloperMode($mode)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2
 getIsDeveloperMode()
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 printException(Exception $e, $extra = '')
0.00%0.00%
0.00% 0 / 1 72
0.00%0.00%
0.00% 0 / 25
 getScriptSystemUrl($folder, $exitIfNot = false)
0.00%0.00%
0.00% 0 / 1 56
0.00%0.00%
0.00% 0 / 28
 setIsDownloader($flag = true)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2


       1                 : <?php                                                                                                                                                        
       2                 : /**                                                                                                                                                          
       3                 :  * Magento                                                                                                                                                   
       4                 :  *                                                                                                                                                           
       5                 :  * NOTICE OF LICENSE                                                                                                                                         
       6                 :  *                                                                                                                                                           
       7                 :  * This source file is subject to the Open Software License (OSL 3.0)                                                                                        
       8                 :  * that is bundled with this package in the file LICENSE.txt.                                                                                                
       9                 :  * It is also available through the world-wide-web at this URL:                                                                                              
      10                 :  * http://opensource.org/licenses/osl-3.0.php                                                                                                                
      11                 :  * If you did not receive a copy of the license and are unable to                                                                                            
      12                 :  * obtain it through the world-wide-web, please send an email                                                                                                
      13                 :  * to license@magentocommerce.com so we can send you a copy immediately.                                                                                     
      14                 :  *                                                                                                                                                           
      15                 :  * DISCLAIMER                                                                                                                                                
      16                 :  *                                                                                                                                                           
      17                 :  * Do not edit or add to this file if you wish to upgrade Magento to newer                                                                                   
      18                 :  * versions in the future. If you wish to customize Magento for your                                                                                         
      19                 :  * needs please refer to http://www.magentocommerce.com for more information.                                                                                
      20                 :  *                                                                                                                                                           
      21                 :  * @category   Mage                                                                                                                                          
      22                 :  * @package    Mage_Core                                                                                                                                     
      23                 :  * @copyright  Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)                                                                  
      24                 :  * @license    http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)                                                                   
      25                 :  */                                                                                                                                                          
      26                 :                                                                                                                                                              
      27                 : define('DS', DIRECTORY_SEPARATOR);                                                                                                                           
      28                 : define('PS', PATH_SEPARATOR);                                                                                                                                
      29                 : define('BP', dirname(dirname(__FILE__)));                                                                                                                    
      30                 :                                                                                                                                                              
      31                 : Mage::register('original_include_path', get_include_path());                                                                                                 
      32                 :                                                                                                                                                              
      33                 : if (defined('COMPILER_INCLUDE_PATH')) {                                                                                                                      
      34                 :     $appPath = COMPILER_INCLUDE_PATH;                                                                                                                        
      35                 :     set_include_path($appPath . PS . Mage::registry('original_include_path'));                                                                               
      36                 :     include_once "Mage_Core_functions.php";                                                                                                                  
      37                 :     include_once "Varien_Autoload.php";                                                                                                                      
      38                 : } else {                                                                                                                                                     
      39                 :     /**                                                                                                                                                      
      40                 :      * Set include path                                                                                                                                      
      41                 :      */                                                                                                                                                      
      42                 :     $paths[] = BP . DS . 'app' . DS . 'code' . DS . 'local';                                                                                                 
      43                 :     $paths[] = BP . DS . 'app' . DS . 'code' . DS . 'community';                                                                                             
      44                 :     $paths[] = BP . DS . 'app' . DS . 'code' . DS . 'core';                                                                                                  
      45                 :     $paths[] = BP . DS . 'lib';                                                                                                                              
      46                 :                                                                                                                                                              
      47                 :     $appPath = implode(PS, $paths);                                                                                                                          
      48                 :     set_include_path($appPath . PS . Mage::registry('original_include_path'));                                                                               
      49                 :     include_once "Mage/Core/functions.php";                                                                                                                  
      50                 :     include_once "Varien/Autoload.php";                                                                                                                      
      51                 : }                                                                                                                                                            
      52                 :                                                                                                                                                              
      53                 : Varien_Autoload::register();                                                                                                                                 
      54                 :                                                                                                                                                              
      55                 : /**                                                                                                                                                          
      56                 :  * Main Mage hub class                                                                                                                                       
      57                 :  *                                                                                                                                                           
      58                 :  * @author      Magento Core Team <core@magentocommerce.com>                                                                                                 
      59                 :  */                                                                                                                                                          
      60                 : final class Mage                                                                                                                                             
      61                 : {                                                                                                                                                            
      62                 :     /**                                                                                                                                                      
      63                 :      * Registry collection                                                                                                                                   
      64                 :      *                                                                                                                                                       
      65                 :      * @var array                                                                                                                                            
      66                 :      */                                                                                                                                                      
      67                 :     static private $_registry                   = array();                                                                                                   
      68                 :                                                                                                                                                              
      69                 :     /**                                                                                                                                                      
      70                 :      * Application root absolute path                                                                                                                        
      71                 :      *                                                                                                                                                       
      72                 :      * @var string                                                                                                                                           
      73                 :      */                                                                                                                                                      
      74                 :     static private $_appRoot;                                                                                                                                
      75                 :                                                                                                                                                              
      76                 :     /**                                                                                                                                                      
      77                 :      * Application model                                                                                                                                     
      78                 :      *                                                                                                                                                       
      79                 :      * @var Mage_Core_Model_App                                                                                                                              
      80                 :      */                                                                                                                                                      
      81                 :     static private $_app;                                                                                                                                    
      82                 :                                                                                                                                                              
      83                 :     /**                                                                                                                                                      
      84                 :      * Config Model                                                                                                                                          
      85                 :      *                                                                                                                                                       
      86                 :      * @var Mage_Core_Model_Config                                                                                                                           
      87                 :      */                                                                                                                                                      
      88                 :     static private $_config;                                                                                                                                 
      89                 :                                                                                                                                                              
      90                 :     /**                                                                                                                                                      
      91                 :      * Event Collection Object                                                                                                                               
      92                 :      *                                                                                                                                                       
      93                 :      * @var Varien_Event_Collection                                                                                                                          
      94                 :      */                                                                                                                                                      
      95                 :     static private $_events;                                                                                                                                 
      96                 :                                                                                                                                                              
      97                 :     /**                                                                                                                                                      
      98                 :      * Object cache instance                                                                                                                                 
      99                 :      *                                                                                                                                                       
     100                 :      * @var Varien_Object_Cache                                                                                                                              
     101                 :      */                                                                                                                                                      
     102                 :     static private $_objects;                                                                                                                                
     103                 :                                                                                                                                                              
     104                 :     /**                                                                                                                                                      
     105                 :      * Is downloader flag                                                                                                                                    
     106                 :      *                                                                                                                                                       
     107                 :      * @var bool                                                                                                                                             
     108                 :      */                                                                                                                                                      
     109                 :     static private $_isDownloader               = false;                                                                                                     
     110                 :                                                                                                                                                              
     111                 :     /**                                                                                                                                                      
     112                 :      * Is developer mode flag                                                                                                                                
     113                 :      *                                                                                                                                                       
     114                 :      * @var bool                                                                                                                                             
     115                 :      */                                                                                                                                                      
     116                 :     static private $_isDeveloperMode            = false;                                                                                                     
     117                 :                                                                                                                                                              
     118                 :     /**                                                                                                                                                      
     119                 :      * Is allow throw Exception about headers already sent                                                                                                   
     120                 :      *                                                                                                                                                       
     121                 :      * @var bool                                                                                                                                             
     122                 :      */                                                                                                                                                      
     123                 :     public static $headersSentThrowsException   = true;                                                                                                      
     124                 :                                                                                                                                                              
     125                 :     /**                                                                                                                                                      
     126                 :      * Is installed flag                                                                                                                                     
     127                 :      *                                                                                                                                                       
     128                 :      * @var bool                                                                                                                                             
     129                 :      */                                                                                                                                                      
     130                 :     static private $_isInstalled;                                                                                                                            
     131                 :                                                                                                                                                              
     132                 :     /**                                                                                                                                                      
     133                 :      * Gets the current Magento version string                                                                                                               
     134                 :      * @link http://www.magentocommerce.com/blog/new-community-edition-release-process/                                                                      
     135                 :      *                                                                                                                                                       
     136                 :      * @return string                                                                                                                                        
     137                 :      */                                                                                                                                                      
     138                 :     public static function getVersion()                                                                                                                      
     139                 :     {                                                                                                                                                        
     140               0 :         $i = self::getVersionInfo();                                                                                                                         
     141               0 :         return trim("{$i['major']}.{$i['minor']}.{$i['revision']}" . ($i['patch'] != '' ? ".{$i['patch']}" : "") . "-{$i['stability']}{$i['number']}", '.-');
     142                 :     }                                                                                                                                                        
     143                 :                                                                                                                                                              
     144                 :     /**                                                                                                                                                      
     145                 :      * Gets the detailed Magento version information                                                                                                         
     146                 :      * @link http://www.magentocommerce.com/blog/new-community-edition-release-process/                                                                      
     147                 :      *                                                                                                                                                       
     148                 :      * @return array                                                                                                                                         
     149                 :      */                                                                                                                                                      
     150                 :     public static function getVersionInfo()                                                                                                                  
     151                 :     {                                                                                                                                                        
     152                 :         return array(                                                                                                                                        
     153               0 :             'major'     => '1',                                                                                                                              
     154               0 :             'minor'     => '5',                                                                                                                              
     155               0 :             'revision'  => '1',                                                                                                                              
     156               0 :             'patch'     => '0',                                                                                                                              
     157               0 :             'stability' => '',                                                                                                                               
     158               0 :             'number'    => '',                                                                                                                               
     159               0 :         );                                                                                                                                                   
     160                 :     }                                                                                                                                                        
     161                 :                                                                                                                                                              
     162                 :     /**                                                                                                                                                      
     163                 :      * Set all my static data to defaults                                                                                                                    
     164                 :      *                                                                                                                                                       
     165                 :      */                                                                                                                                                      
     166                 :     public static function reset()                                                                                                                           
     167                 :     {                                                                                                                                                        
     168               0 :         self::$_registry        = array();                                                                                                                   
     169               0 :         self::$_app             = null;                                                                                                                      
     170               0 :         self::$_config          = null;                                                                                                                      
     171               0 :         self::$_events          = null;                                                                                                                      
     172               0 :         self::$_objects         = null;                                                                                                                      
     173               0 :         self::$_isDownloader    = false;                                                                                                                     
     174               0 :         self::$_isDeveloperMode = false;                                                                                                                     
     175                 :         // do not reset $headersSentThrowsException                                                                                                          
     176               0 :     }                                                                                                                                                        
     177                 :                                                                                                                                                              
     178                 :     /**                                                                                                                                                      
     179                 :      * Register a new variable                                                                                                                               
     180                 :      *                                                                                                                                                       
     181                 :      * @param string $key                                                                                                                                    
     182                 :      * @param mixed $value                                                                                                                                   
     183                 :      * @param bool $graceful                                                                                                                                 
     184                 :      * @throws Mage_Core_Exception                                                                                                                           
     185                 :      */                                                                                                                                                      
     186                 :     public static function register($key, $value, $graceful = false)                                                                                         
     187                 :     {                                                                                                                                                        
     188               2 :         if (isset(self::$_registry[$key])) {                                                                                                                 
     189               0 :             if ($graceful) {                                                                                                                                 
     190               0 :                 return;                                                                                                                                      
     191                 :             }                                                                                                                                                
     192               0 :             self::throwException('Mage registry key "'.$key.'" already exists');                                                                             
     193               0 :         }                                                                                                                                                    
     194               2 :         self::$_registry[$key] = $value;                                                                                                                     
     195               2 :     }                                                                                                                                                        
     196                 :                                                                                                                                                              
     197                 :     /**                                                                                                                                                      
     198                 :      * Unregister a variable from register by key                                                                                                            
     199                 :      *                                                                                                                                                       
     200                 :      * @param string $key                                                                                                                                    
     201                 :      */                                                                                                                                                      
     202                 :     public static function unregister($key)                                                                                                                  
     203                 :     {                                                                                                                                                        
     204               0 :         if (isset(self::$_registry[$key])) {                                                                                                                 
     205               0 :             if (is_object(self::$_registry[$key]) && (method_exists(self::$_registry[$key], '__destruct'))) {                                                
     206               0 :                 self::$_registry[$key]->__destruct();                                                                                                        
     207               0 :             }                                                                                                                                                
     208               0 :             unset(self::$_registry[$key]);                                                                                                                   
     209               0 :         }                                                                                                                                                    
     210               0 :     }                                                                                                                                                        
     211                 :                                                                                                                                                              
     212                 :     /**                                                                                                                                                      
     213                 :      * Retrieve a value from registry by a key                                                                                                               
     214                 :      *                                                                                                                                                       
     215                 :      * @param string $key                                                                                                                                    
     216                 :      * @return mixed                                                                                                                                         
     217                 :      */                                                                                                                                                      
     218                 :     public static function registry($key)                                                                                                                    
     219                 :     {                                                                                                                                                        
     220              19 :         if (isset(self::$_registry[$key])) {                                                                                                                 
     221              19 :             return self::$_registry[$key];                                                                                                                   
     222                 :         }                                                                                                                                                    
     223               2 :         return null;                                                                                                                                         
     224                 :     }                                                                                                                                                        
     225                 :                                                                                                                                                              
     226                 :     /**                                                                                                                                                      
     227                 :      * Set application root absolute path                                                                                                                    
     228                 :      *                                                                                                                                                       
     229                 :      * @param string $appRoot                                                                                                                                
     230                 :      * @throws Mage_Core_Exception                                                                                                                           
     231                 :      */                                                                                                                                                      
     232                 :     public static function setRoot($appRoot = '')                                                                                                            
     233                 :     {                                                                                                                                                        
     234               0 :         if (self::$_appRoot) {                                                                                                                               
     235               0 :             return ;                                                                                                                                         
     236                 :         }                                                                                                                                                    
     237                 :                                                                                                                                                              
     238               0 :         if ('' === $appRoot) {                                                                                                                               
     239                 :             // automagically find application root by dirname of Mage.php                                                                                    
     240               0 :             $appRoot = dirname(__FILE__);                                                                                                                    
     241               0 :         }                                                                                                                                                    
     242                 :                                                                                                                                                              
     243               0 :         $appRoot = realpath($appRoot);                                                                                                                       
     244                 :                                                                                                                                                              
     245               0 :         if (is_dir($appRoot) and is_readable($appRoot)) {                                                                                                    
     246               0 :             self::$_appRoot = $appRoot;                                                                                                                      
     247               0 :         } else {                                                                                                                                             
     248               0 :             self::throwException($appRoot . ' is not a directory or not readable by this user');                                                             
     249                 :         }                                                                                                                                                    
     250               0 :     }                                                                                                                                                        
     251                 :                                                                                                                                                              
     252                 :     /**                                                                                                                                                      
     253                 :      * Retrieve application root absolute path                                                                                                               
     254                 :      *                                                                                                                                                       
     255                 :      * @return string                                                                                                                                        
     256                 :      */                                                                                                                                                      
     257                 :     public static function getRoot()                                                                                                                         
     258                 :     {                                                                                                                                                        
     259               0 :         return self::$_appRoot;                                                                                                                              
     260                 :     }                                                                                                                                                        
     261                 :                                                                                                                                                              
     262                 :     /**                                                                                                                                                      
     263                 :      * Retrieve Events Collection                                                                                                                            
     264                 :      *                                                                                                                                                       
     265                 :      * @return Varien_Event_Collection $collection                                                                                                           
     266                 :      */                                                                                                                                                      
     267                 :     public static function getEvents()                                                                                                                       
     268                 :     {                                                                                                                                                        
     269               0 :         return self::$_events;                                                                                                                               
     270                 :     }                                                                                                                                                        
     271                 :                                                                                                                                                              
     272                 :     /**                                                                                                                                                      
     273                 :      * Varien Objects Cache                                                                                                                                  
     274                 :      *                                                                                                                                                       
     275                 :      * @param string $key optional, if specified will load this key                                                                                          
     276                 :      * @return Varien_Object_Cache                                                                                                                           
     277                 :      */                                                                                                                                                      
     278                 :     public static function objects($key = null)                                                                                                              
     279                 :     {                                                                                                                                                        
     280               3 :         if (!self::$_objects) {                                                                                                                              
     281               1 :             self::$_objects = new Varien_Object_Cache;                                                                                                       
     282               1 :         }                                                                                                                                                    
     283               3 :         if (is_null($key)) {                                                                                                                                 
     284               3 :             return self::$_objects;                                                                                                                          
     285                 :         } else {                                                                                                                                             
     286               3 :             return self::$_objects->load($key);                                                                                                              
     287                 :         }                                                                                                                                                    
     288                 :     }                                                                                                                                                        
     289                 :                                                                                                                                                              
     290                 :     /**                                                                                                                                                      
     291                 :      * Retrieve application root absolute path                                                                                                               
     292                 :      *                                                                                                                                                       
     293                 :      * @param string $type                                                                                                                                   
     294                 :      * @return string                                                                                                                                        
     295                 :      */                                                                                                                                                      
     296                 :     public static function getBaseDir($type = 'base')                                                                                                        
     297                 :     {                                                                                                                                                        
     298               4 :         return self::getConfig()->getOptions()->getDir($type);                                                                                               
     299                 :     }                                                                                                                                                        
     300                 :                                                                                                                                                              
     301                 :     /**                                                                                                                                                      
     302                 :      * Retrieve module absolute path by directory type                                                                                                       
     303                 :      *                                                                                                                                                       
     304                 :      * @param string $type                                                                                                                                   
     305                 :      * @param string $moduleName                                                                                                                             
     306                 :      * @return string                                                                                                                                        
     307                 :      */                                                                                                                                                      
     308                 :     public static function getModuleDir($type, $moduleName)                                                                                                  
     309                 :     {                                                                                                                                                        
     310               0 :         return self::getConfig()->getModuleDir($type, $moduleName);                                                                                          
     311                 :     }                                                                                                                                                        
     312                 :                                                                                                                                                              
     313                 :     /**                                                                                                                                                      
     314                 :      * Retrieve config value for store by path                                                                                                               
     315                 :      *                                                                                                                                                       
     316                 :      * @param string $path                                                                                                                                   
     317                 :      * @param mixed $store                                                                                                                                   
     318                 :      * @return mixed                                                                                                                                         
     319                 :      */                                                                                                                                                      
     320                 :     public static function getStoreConfig($path, $store = null)                                                                                              
     321                 :     {                                                                                                                                                        
     322              16 :         return self::app()->getStore($store)->getConfig($path);                                                                                              
     323                 :     }                                                                                                                                                        
     324                 :                                                                                                                                                              
     325                 :     /**                                                                                                                                                      
     326                 :      * Retrieve config flag for store by path                                                                                                                
     327                 :      *                                                                                                                                                       
     328                 :      * @param string $path                                                                                                                                   
     329                 :      * @param mixed $store                                                                                                                                   
     330                 :      * @return bool                                                                                                                                          
     331                 :      */                                                                                                                                                      
     332                 :     public static function getStoreConfigFlag($path, $store = null)                                                                                          
     333                 :     {                                                                                                                                                        
     334               2 :         $flag = strtolower(self::getStoreConfig($path, $store));                                                                                             
     335               2 :         if (!empty($flag) && 'false' !== $flag) {                                                                                                            
     336               1 :             return true;                                                                                                                                     
     337                 :         } else {                                                                                                                                             
     338               1 :             return false;                                                                                                                                    
     339                 :         }                                                                                                                                                    
     340                 :     }                                                                                                                                                        
     341                 :                                                                                                                                                              
     342                 :     /**                                                                                                                                                      
     343                 :      * Get base URL path by type                                                                                                                             
     344                 :      *                                                                                                                                                       
     345                 :      * @param string $type                                                                                                                                   
     346                 :      * @return string                                                                                                                                        
     347                 :      */                                                                                                                                                      
     348                 :     public static function getBaseUrl($type = Mage_Core_Model_Store::URL_TYPE_LINK, $secure = null)                                                          
     349                 :     {                                                                                                                                                        
     350               5 :         return self::app()->getStore()->getBaseUrl($type, $secure);                                                                                          
     351                 :     }                                                                                                                                                        
     352                 :                                                                                                                                                              
     353                 :     /**                                                                                                                                                      
     354                 :      * Generate url by route and parameters                                                                                                                  
     355                 :      *                                                                                                                                                       
     356                 :      * @param   string $route                                                                                                                                
     357                 :      * @param   array $params                                                                                                                                
     358                 :      * @return  string                                                                                                                                       
     359                 :      */                                                                                                                                                      
     360                 :     public static function getUrl($route = '', $params = array())                                                                                            
     361                 :     {                                                                                                                                                        
     362               0 :         return self::getModel('core/url')->getUrl($route, $params);                                                                                          
     363                 :     }                                                                                                                                                        
     364                 :                                                                                                                                                              
     365                 :     /**                                                                                                                                                      
     366                 :      * Get design package singleton                                                                                                                          
     367                 :      *                                                                                                                                                       
     368                 :      * @return Mage_Core_Model_Design_Package                                                                                                                
     369                 :      */                                                                                                                                                      
     370                 :     public static function getDesign()                                                                                                                       
     371                 :     {                                                                                                                                                        
     372               0 :         return self::getSingleton('core/design_package');                                                                                                    
     373                 :     }                                                                                                                                                        
     374                 :                                                                                                                                                              
     375                 :     /**                                                                                                                                                      
     376                 :      * Retrieve a config instance                                                                                                                            
     377                 :      *                                                                                                                                                       
     378                 :      * @return Mage_Core_Model_Config                                                                                                                        
     379                 :      */                                                                                                                                                      
     380                 :     public static function getConfig()                                                                                                                       
     381                 :     {                                                                                                                                                        
     382              19 :         return self::$_config;                                                                                                                               
     383                 :     }                                                                                                                                                        
     384                 :                                                                                                                                                              
     385                 :     /**                                                                                                                                                      
     386                 :      * Add observer to even object                                                                                                                           
     387                 :      *                                                                                                                                                       
     388                 :      * @param string $eventName                                                                                                                              
     389                 :      * @param callback $callback                                                                                                                             
     390                 :      * @param array $arguments                                                                                                                               
     391                 :      * @param string $observerName                                                                                                                           
     392                 :      */                                                                                                                                                      
     393                 :     public static function addObserver($eventName, $callback, $data = array(), $observerName = '', $observerClass = '')                                      
     394                 :     {                                                                                                                                                        
     395               0 :         if ($observerClass == '') {                                                                                                                          
     396               0 :             $observerClass = 'Varien_Event_Observer';                                                                                                        
     397               0 :         }                                                                                                                                                    
     398               0 :         $observer = new $observerClass();                                                                                                                    
     399               0 :         $observer->setName($observerName)->addData($data)->setEventName($eventName)->setCallback($callback);                                                 
     400               0 :         return self::getEvents()->addObserver($observer);                                                                                                    
     401                 :     }                                                                                                                                                        
     402                 :                                                                                                                                                              
     403                 :     /**                                                                                                                                                      
     404                 :      * Dispatch event                                                                                                                                        
     405                 :      *                                                                                                                                                       
     406                 :      * Calls all observer callbacks registered for this event                                                                                                
     407                 :      * and multiobservers matching event name pattern                                                                                                        
     408                 :      *                                                                                                                                                       
     409                 :      * @param string $name                                                                                                                                   
     410                 :      * @param array $args                                                                                                                                    
     411                 :      * @return Mage_Core_Model_App                                                                                                                           
     412                 :      */                                                                                                                                                      
     413                 :     public static function dispatchEvent($name, array $data = array())                                                                                       
     414                 :     {                                                                                                                                                        
     415              16 :         Varien_Profiler::start('DISPATCH EVENT:'.$name);                                                                                                     
     416              16 :         $result = self::app()->dispatchEvent($name, $data);                                                                                                  
     417                 :         #$result = self::registry('events')->dispatch($name, $data);                                                                                         
     418              16 :         Varien_Profiler::stop('DISPATCH EVENT:'.$name);                                                                                                      
     419              16 :         return $result;                                                                                                                                      
     420                 :     }                                                                                                                                                        
     421                 :                                                                                                                                                              
     422                 :     /**                                                                                                                                                      
     423                 :      * Retrieve model object                                                                                                                                 
     424                 :      *                                                                                                                                                       
     425                 :      * @link    Mage_Core_Model_Config::getModelInstance                                                                                                     
     426                 :      * @param   string $modelClass                                                                                                                           
     427                 :      * @param   array $arguments                                                                                                                             
     428                 :      * @return  Mage_Core_Model_Abstract                                                                                                                     
     429                 :      */                                                                                                                                                      
     430                 :     public static function getModel($modelClass = '', $arguments = array())                                                                                  
     431                 :     {                                                                                                                                                        
     432              18 :         return self::getConfig()->getModelInstance($modelClass, $arguments);                                                                                 
     433                 :     }                                                                                                                                                        
     434                 :                                                                                                                                                              
     435                 :     /**                                                                                                                                                      
     436                 :      * Retrieve model object singleton                                                                                                                       
     437                 :      *                                                                                                                                                       
     438                 :      * @param   string $modelClass                                                                                                                           
     439                 :      * @param   array $arguments                                                                                                                             
     440                 :      * @return  Mage_Core_Model_Abstract                                                                                                                     
     441                 :      */                                                                                                                                                      
     442                 :     public static function getSingleton($modelClass='', array $arguments=array())                                                                            
     443                 :     {                                                                                                                                                        
     444              19 :         $registryKey = '_singleton/'.$modelClass;                                                                                                            
     445              19 :         if (!self::registry($registryKey)) {                                                                                                                 
     446               2 :             self::register($registryKey, self::getModel($modelClass, $arguments));                                                                           
     447               2 :         }                                                                                                                                                    
     448              19 :         return self::registry($registryKey);                                                                                                                 
     449                 :     }                                                                                                                                                        
     450                 :                                                                                                                                                              
     451                 :     /**                                                                                                                                                      
     452                 :      * Retrieve object of resource model                                                                                                                     
     453                 :      *                                                                                                                                                       
     454                 :      * @param   string $modelClass                                                                                                                           
     455                 :      * @param   array $arguments                                                                                                                             
     456                 :      * @return  Object                                                                                                                                       
     457                 :      */                                                                                                                                                      
     458                 :     public static function getResourceModel($modelClass, $arguments = array())                                                                               
     459                 :     {                                                                                                                                                        
     460              15 :         return self::getConfig()->getResourceModelInstance($modelClass, $arguments);                                                                         
     461                 :     }                                                                                                                                                        
     462                 :                                                                                                                                                              
     463                 :     /**                                                                                                                                                      
     464                 :      * Retrieve Controller instance by ClassName                                                                                                             
     465                 :      *                                                                                                                                                       
     466                 :      * @param string $class                                                                                                                                  
     467                 :      * @param Mage_Core_Controller_Request_Http $request                                                                                                     
     468                 :      * @param Mage_Core_Controller_Response_Http $response                                                                                                   
     469                 :      * @param array $invokeArgs                                                                                                                              
     470                 :      * @return Mage_Core_Controller_Front_Action                                                                                                             
     471                 :      */                                                                                                                                                      
     472                 :     public static function getControllerInstance($class, $request, $response, array $invokeArgs = array())                                                   
     473                 :     {                                                                                                                                                        
     474               0 :         return new $class($request, $response, $invokeArgs);                                                                                                 
     475                 :     }                                                                                                                                                        
     476                 :                                                                                                                                                              
     477                 :     /**                                                                                                                                                      
     478                 :      * Retrieve resource vodel object singleton                                                                                                              
     479                 :      *                                                                                                                                                       
     480                 :      * @param   string $modelClass                                                                                                                           
     481                 :      * @param   array $arguments                                                                                                                             
     482                 :      * @return  object                                                                                                                                       
     483                 :      */                                                                                                                                                      
     484                 :     public static function getResourceSingleton($modelClass = '', array $arguments = array())                                                                
     485                 :     {                                                                                                                                                        
     486              15 :         $registryKey = '_resource_singleton/'.$modelClass;                                                                                                   
     487              15 :         if (!self::registry($registryKey)) {                                                                                                                 
     488               1 :             self::register($registryKey, self::getResourceModel($modelClass, $arguments));                                                                   
     489               1 :         }                                                                                                                                                    
     490              15 :         return self::registry($registryKey);                                                                                                                 
     491                 :     }                                                                                                                                                        
     492                 :                                                                                                                                                              
     493                 :     /**                                                                                                                                                      
     494                 :      * Deprecated, use self::helper()                                                                                                                        
     495                 :      *                                                                                                                                                       
     496                 :      * @param string $type                                                                                                                                   
     497                 :      * @return object                                                                                                                                        
     498                 :      */                                                                                                                                                      
     499                 :     public static function getBlockSingleton($type)                                                                                                          
     500                 :     {                                                                                                                                                        
     501               0 :         $action = self::app()->getFrontController()->getAction();                                                                                            
     502               0 :         return $action ? $action->getLayout()->getBlockSingleton($type) : false;                                                                             
     503                 :     }                                                                                                                                                        
     504                 :                                                                                                                                                              
     505                 :     /**                                                                                                                                                      
     506                 :      * Retrieve helper object                                                                                                                                
     507                 :      *                                                                                                                                                       
     508                 :      * @param string $name the helper name                                                                                                                   
     509                 :      * @return Mage_Core_Helper_Abstract                                                                                                                     
     510                 :      */                                                                                                                                                      
     511                 :     public static function helper($name)                                                                                                                     
     512                 :     {                                                                                                                                                        
     513              15 :         if (strpos($name, '/') === false) {                                                                                                                  
     514              15 :             $name .= '/data';                                                                                                                                
     515              15 :         }                                                                                                                                                    
     516                 :                                                                                                                                                              
     517              15 :         $registryKey = '_helper/' . $name;                                                                                                                   
     518              15 :         if (!self::registry($registryKey)) {                                                                                                                 
     519               1 :             $helperClass = self::getConfig()->getHelperClassName($name);                                                                                     
     520               1 :             self::register($registryKey, new $helperClass);                                                                                                  
     521               1 :         }                                                                                                                                                    
     522              15 :         return self::registry($registryKey);                                                                                                                 
     523                 :     }                                                                                                                                                        
     524                 :                                                                                                                                                              
     525                 :     /**                                                                                                                                                      
     526                 :      * Return new exception by module to be thrown                                                                                                           
     527                 :      *                                                                                                                                                       
     528                 :      * @param string $module                                                                                                                                 
     529                 :      * @param string $message                                                                                                                                
     530                 :      * @param integer $code                                                                                                                                  
     531                 :      * @return Mage_Core_Exception                                                                                                                           
     532                 :      */                                                                                                                                                      
     533                 :     public static function exception($module = 'Mage_Core', $message = '', $code = 0)                                                                        
     534                 :     {                                                                                                                                                        
     535               0 :         $className = $module.'_Exception';                                                                                                                   
     536               0 :         return new $className($message, $code);                                                                                                              
     537                 :     }                                                                                                                                                        
     538                 :                                                                                                                                                              
     539                 :     /**                                                                                                                                                      
     540                 :      * Throw Exception                                                                                                                                       
     541                 :      *                                                                                                                                                       
     542                 :      * @param string $message                                                                                                                                
     543                 :      * @param string $messageStorage                                                                                                                         
     544                 :      */                                                                                                                                                      
     545                 :     public static function throwException($message, $messageStorage = null)                                                                                  
     546                 :     {                                                                                                                                                        
     547               0 :         if ($messageStorage && ($storage = self::getSingleton($messageStorage))) {                                                                           
     548               0 :             $storage->addError($message);                                                                                                                    
     549               0 :         }                                                                                                                                                    
     550               0 :         throw new Mage_Core_Exception($message);                                                                                                             
     551                 :     }                                                                                                                                                        
     552                 :                                                                                                                                                              
     553                 :     /**                                                                                                                                                      
     554                 :      * Get initialized application object.                                                                                                                   
     555                 :      *                                                                                                                                                       
     556                 :      * @param string $code                                                                                                                                   
     557                 :      * @param string $type                                                                                                                                   
     558                 :      * @param string|array $options                                                                                                                          
     559                 :      * @return Mage_Core_Model_App                                                                                                                           
     560                 :      */                                                                                                                                                      
     561                 :     public static function app($code = '', $type = 'store', $options = array())                                                                              
     562                 :     {                                                                                                                                                        
     563              19 :         if (null === self::$_app) {                                                                                                                          
     564               0 :             self::$_app = new Mage_Core_Model_App();                                                                                                         
     565               0 :             self::setRoot();                                                                                                                                 
     566               0 :             self::$_events = new Varien_Event_Collection();                                                                                                  
     567               0 :             self::$_config = new Mage_Core_Model_Config();                                                                                                   
     568                 :                                                                                                                                                              
     569               0 :             Varien_Profiler::start('self::app::init');                                                                                                       
     570               0 :             self::$_app->init($code, $type, $options);                                                                                                       
     571               0 :             Varien_Profiler::stop('self::app::init');                                                                                                        
     572               0 :             self::$_app->loadAreaPart(Mage_Core_Model_App_Area::AREA_GLOBAL, Mage_Core_Model_App_Area::PART_EVENTS);                                         
     573               0 :         }                                                                                                                                                    
     574              19 :         return self::$_app;                                                                                                                                  
     575                 :     }                                                                                                                                                        
     576                 :                                                                                                                                                              
     577                 :     /**                                                                                                                                                      
     578                 :      * @static                                                                                                                                               
     579                 :      * @param string $code                                                                                                                                   
     580                 :      * @param string $type                                                                                                                                   
     581                 :      * @param array $options                                                                                                                                 
     582                 :      * @param string|array $modules                                                                                                                          
     583                 :      */                                                                                                                                                      
     584                 :     public static function init($code = '', $type = 'store', $options = array(), $modules = array())                                                         
     585                 :     {                                                                                                                                                        
     586                 :         try {                                                                                                                                                
     587               0 :             self::setRoot();                                                                                                                                 
     588               0 :             self::$_app     = new Mage_Core_Model_App();                                                                                                     
     589               0 :             self::$_config  = new Mage_Core_Model_Config();                                                                                                  
     590                 :                                                                                                                                                              
     591               0 :             if (!empty($modules)) {                                                                                                                          
     592               0 :                 self::$_app->initSpecified($code, $type, $options, $modules);                                                                                
     593               0 :             } else {                                                                                                                                         
     594               0 :                 self::$_app->init($code, $type, $options);                                                                                                   
     595                 :             }                                                                                                                                                
     596               0 :         } catch (Mage_Core_Model_Session_Exception $e) {                                                                                                     
     597               0 :             header('Location: ' . self::getBaseUrl());                                                                                                       
     598               0 :             die;                                                                                                                                             
     599               0 :         } catch (Mage_Core_Model_Store_Exception $e) {                                                                                                       
     600               0 :             require_once(self::getBaseDir() . DS . 'errors' . DS . '404.php');                                                                               
     601               0 :             die;                                                                                                                                             
     602               0 :         } catch (Exception $e) {                                                                                                                             
     603               0 :             self::printException($e);                                                                                                                        
     604               0 :             die;                                                                                                                                             
     605                 :         }                                                                                                                                                    
     606               0 :     }                                                                                                                                                        
     607                 :                                                                                                                                                              
     608                 :     /**                                                                                                                                                      
     609                 :      * Front end main entry point                                                                                                                            
     610                 :      *                                                                                                                                                       
     611                 :      * @param string $code                                                                                                                                   
     612                 :      * @param string $type                                                                                                                                   
     613                 :      * @param string|array $options                                                                                                                          
     614                 :      */                                                                                                                                                      
     615                 :     public static function run($code = '', $type = 'store', $options=array())                                                                                
     616                 :     {                                                                                                                                                        
     617                 :         try {                                                                                                                                                
     618               0 :             Varien_Profiler::start('mage');                                                                                                                  
     619               0 :             self::setRoot();                                                                                                                                 
     620               0 :             self::$_app     = new Mage_Core_Model_App();                                                                                                     
     621               0 :             self::$_events  = new Varien_Event_Collection();                                                                                                 
     622               0 :             self::$_config  = new Mage_Core_Model_Config();                                                                                                  
     623               0 :             self::$_app->run(array(                                                                                                                          
     624               0 :                 'scope_code' => $code,                                                                                                                       
     625               0 :                 'scope_type' => $type,                                                                                                                       
     626               0 :                 'options'    => $options,                                                                                                                    
     627               0 :             ));                                                                                                                                              
     628               0 :             Varien_Profiler::stop('mage');                                                                                                                   
     629               0 :         } catch (Mage_Core_Model_Session_Exception $e) {                                                                                                     
     630               0 :             header('Location: ' . self::getBaseUrl());                                                                                                       
     631               0 :             die();                                                                                                                                           
     632               0 :         } catch (Mage_Core_Model_Store_Exception $e) {                                                                                                       
     633               0 :             require_once(self::getBaseDir() . DS . 'errors' . DS . '404.php');                                                                               
     634               0 :             die();                                                                                                                                           
     635               0 :         } catch (Exception $e) {                                                                                                                             
     636               0 :             if (self::isInstalled() || self::$_isDownloader) {                                                                                               
     637               0 :                 self::printException($e);                                                                                                                    
     638               0 :                 exit();                                                                                                                                      
     639                 :             }                                                                                                                                                
     640                 :             try {                                                                                                                                            
     641               0 :                 self::dispatchEvent('mage_run_exception', array('exception' => $e));                                                                         
     642               0 :                 if (!headers_sent()) {                                                                                                                       
     643               0 :                     header('Location:' . self::getUrl('install'));                                                                                           
     644               0 :                 } else {                                                                                                                                     
     645               0 :                     self::printException($e);                                                                                                                
     646                 :                 }                                                                                                                                            
     647               0 :             } catch (Exception $ne) {                                                                                                                        
     648               0 :                 self::printException($ne, $e->getMessage());                                                                                                 
     649                 :             }                                                                                                                                                
     650                 :         }                                                                                                                                                    
     651               0 :     }                                                                                                                                                        
     652                 :                                                                                                                                                              
     653                 :     /**                                                                                                                                                      
     654                 :      * Retrieve application installation flag                                                                                                                
     655                 :      *                                                                                                                                                       
     656                 :      * @param string|array $options                                                                                                                          
     657                 :      * @return bool                                                                                                                                          
     658                 :      */                                                                                                                                                      
     659                 :     public static function isInstalled($options = array())                                                                                                   
     660                 :     {                                                                                                                                                        
     661              17 :         if (self::$_isInstalled === null) {                                                                                                                  
     662               0 :             self::setRoot();                                                                                                                                 
     663                 :                                                                                                                                                              
     664               0 :             if (is_string($options)) {                                                                                                                       
     665               0 :                 $options = array('etc_dir' => $options);                                                                                                     
     666               0 :             }                                                                                                                                                
     667               0 :             $etcDir = 'etc';                                                                                                                                 
     668               0 :             if (!empty($options['etc_dir'])) {                                                                                                               
     669               0 :                 $etcDir = $options['etc_dir'];                                                                                                               
     670               0 :             }                                                                                                                                                
     671               0 :             $localConfigFile = self::getRoot() . DS . $etcDir . DS . 'local.xml';                                                                            
     672                 :                                                                                                                                                              
     673               0 :             self::$_isInstalled = false;                                                                                                                     
     674                 :                                                                                                                                                              
     675               0 :             if (is_readable($localConfigFile)) {                                                                                                             
     676               0 :                 $localConfig = simplexml_load_file($localConfigFile);                                                                                        
     677               0 :                 date_default_timezone_set('UTC');                                                                                                            
     678               0 :                 if (($date = $localConfig->global->install->date) && strtotime($date)) {                                                                     
     679               0 :                     self::$_isInstalled = true;                                                                                                              
     680               0 :                 }                                                                                                                                            
     681               0 :             }                                                                                                                                                
     682               0 :         }                                                                                                                                                    
     683              17 :         return self::$_isInstalled;                                                                                                                          
     684                 :     }                                                                                                                                                        
     685                 :                                                                                                                                                              
     686                 :     /**                                                                                                                                                      
     687                 :      * log facility (??)                                                                                                                                     
     688                 :      *                                                                                                                                                       
     689                 :      * @param string $message                                                                                                                                
     690                 :      * @param integer $level                                                                                                                                 
     691                 :      * @param string $file                                                                                                                                   
     692                 :      * @param bool $forceLog                                                                                                                                 
     693                 :      */                                                                                                                                                      
     694                 :     public static function log($message, $level = null, $file = '', $forceLog = false)                                                                       
     695                 :     {                                                                                                                                                        
     696               7 :         if (!self::getConfig()) {                                                                                                                            
     697               0 :             return;                                                                                                                                          
     698                 :         }                                                                                                                                                    
     699                 :                                                                                                                                                              
     700                 :         try {                                                                                                                                                
     701               7 :             $logActive = self::getStoreConfig('dev/log/active');                                                                                             
     702               7 :             if (empty($file)) {                                                                                                                              
     703               7 :                 $file = self::getStoreConfig('dev/log/file');                                                                                                
     704               7 :             }                                                                                                                                                
     705                 :         }                                                                                                                                                    
     706               7 :         catch (Exception $e) {                                                                                                                               
     707               0 :             $logActive = true;                                                                                                                               
     708                 :         }                                                                                                                                                    
     709                 :                                                                                                                                                              
     710               7 :         if (!self::$_isDeveloperMode && !$logActive && !$forceLog) {                                                                                         
     711               0 :             return;                                                                                                                                          
     712                 :         }                                                                                                                                                    
     713                 :                                                                                                                                                              
     714               7 :         static $loggers = array();                                                                                                                           
     715                 :                                                                                                                                                              
     716               7 :         $level  = is_null($level) ? Zend_Log::DEBUG : $level;                                                                                                
     717               7 :         $file = empty($file) ? 'system.log' : $file;                                                                                                         
     718                 :                                                                                                                                                              
     719                 :         try {                                                                                                                                                
     720               7 :             if (!isset($loggers[$file])) {                                                                                                                   
     721               0 :                 $logFile = self::getBaseDir('var') . DS . 'log' . DS . $file;                                                                                
     722                 :                                                                                                                                                              
     723               0 :                 if (!is_dir(self::getBaseDir('var').DS.'log')) {                                                                                             
     724               0 :                     mkdir(self::getBaseDir('var').DS.'log', 0777);                                                                                           
     725               0 :                 }                                                                                                                                            
     726                 :                                                                                                                                                              
     727               0 :                 if (!file_exists($logFile)) {                                                                                                                
     728               0 :                     file_put_contents($logFile, '');                                                                                                         
     729               0 :                     chmod($logFile, 0777);                                                                                                                   
     730               0 :                 }                                                                                                                                            
     731                 :                                                                                                                                                              
     732               0 :                 $format = '%timestamp% %priorityName% (%priority%): %message%' . PHP_EOL;                                                                    
     733               0 :                 $formatter = new Zend_Log_Formatter_Simple($format);                                                                                         
     734               0 :                 $writerModel = (string)self::getConfig()->getNode('global/log/core/writer_model');                                                           
     735               0 :                 if (!self::$_app || !$writerModel) {                                                                                                         
     736               0 :                     $writer = new Zend_Log_Writer_Stream($logFile);                                                                                          
     737               0 :                 }                                                                                                                                            
     738                 :                 else {                                                                                                                                       
     739               0 :                     $writer = new $writerModel($logFile);                                                                                                    
     740                 :                 }                                                                                                                                            
     741               0 :                 $writer->setFormatter($formatter);                                                                                                           
     742               0 :                 $loggers[$file] = new Zend_Log($writer);                                                                                                     
     743               0 :             }                                                                                                                                                
     744                 :                                                                                                                                                              
     745               7 :             if (is_array($message) || is_object($message)) {                                                                                                 
     746               0 :                 $message = print_r($message, true);                                                                                                          
     747               0 :             }                                                                                                                                                
     748                 :                                                                                                                                                              
     749               7 :             $loggers[$file]->log($message, $level);                                                                                                          
     750                 :         }                                                                                                                                                    
     751               7 :         catch (Exception $e) {                                                                                                                               
     752                 :         }                                                                                                                                                    
     753               7 :     }                                                                                                                                                        
     754                 :                                                                                                                                                              
     755                 :     /**                                                                                                                                                      
     756                 :      * Write exception to log                                                                                                                                
     757                 :      *                                                                                                                                                       
     758                 :      * @param Exception $e                                                                                                                                   
     759                 :      */                                                                                                                                                      
     760                 :     public static function logException(Exception $e)                                                                                                        
     761                 :     {                                                                                                                                                        
     762               0 :         if (!self::getConfig()) {                                                                                                                            
     763               0 :             return;                                                                                                                                          
     764                 :         }                                                                                                                                                    
     765               0 :         $file = self::getStoreConfig('dev/log/exception_file');                                                                                              
     766               0 :         self::log("\n" . $e->__toString(), Zend_Log::ERR, $file);                                                                                            
     767               0 :     }                                                                                                                                                        
     768                 :                                                                                                                                                              
     769                 :     /**                                                                                                                                                      
     770                 :      * Set enabled developer mode                                                                                                                            
     771                 :      *                                                                                                                                                       
     772                 :      * @param bool $mode                                                                                                                                     
     773                 :      * @return bool                                                                                                                                          
     774                 :      */                                                                                                                                                      
     775                 :     public static function setIsDeveloperMode($mode)                                                                                                         
     776                 :     {                                                                                                                                                        
     777               0 :         self::$_isDeveloperMode = (bool)$mode;                                                                                                               
     778               0 :         return self::$_isDeveloperMode;                                                                                                                      
     779                 :     }                                                                                                                                                        
     780                 :                                                                                                                                                              
     781                 :     /**                                                                                                                                                      
     782                 :      * Retrieve enabled developer mode                                                                                                                       
     783                 :      *                                                                                                                                                       
     784                 :      * @return bool                                                                                                                                          
     785                 :      */                                                                                                                                                      
     786                 :     public static function getIsDeveloperMode()                                                                                                              
     787                 :     {                                                                                                                                                        
     788               2 :         return self::$_isDeveloperMode;                                                                                                                      
     789                 :     }                                                                                                                                                        
     790                 :                                                                                                                                                              
     791                 :     /**                                                                                                                                                      
     792                 :      * Display exception                                                                                                                                     
     793                 :      *                                                                                                                                                       
     794                 :      * @param Exception $e                                                                                                                                   
     795                 :      */                                                                                                                                                      
     796                 :     public static function printException(Exception $e, $extra = '')                                                                                         
     797                 :     {                                                                                                                                                        
     798               0 :         if (self::$_isDeveloperMode) {                                                                                                                       
     799               0 :             print '<pre>';                                                                                                                                   
     800                 :                                                                                                                                                              
     801               0 :             if (!empty($extra)) {                                                                                                                            
     802               0 :                 print $extra . "\n\n";                                                                                                                       
     803               0 :             }                                                                                                                                                
     804                 :                                                                                                                                                              
     805               0 :             print $e->getMessage() . "\n\n";                                                                                                                 
     806               0 :             print $e->getTraceAsString();                                                                                                                    
     807               0 :             print '</pre>';                                                                                                                                  
     808               0 :         } else {                                                                                                                                             
     809                 :                                                                                                                                                              
     810                 :             $reportData = array(                                                                                                                             
     811               0 :                 !empty($extra) ? $extra . "\n\n" : '' . $e->getMessage(),                                                                                    
     812               0 :                 $e->getTraceAsString()                                                                                                                       
     813               0 :             );                                                                                                                                               
     814                 :                                                                                                                                                              
     815                 :             // retrieve server data                                                                                                                          
     816               0 :             if (isset($_SERVER)) {                                                                                                                           
     817               0 :                 if (isset($_SERVER['REQUEST_URI'])) {                                                                                                        
     818               0 :                     $reportData['url'] = $_SERVER['REQUEST_URI'];                                                                                            
     819               0 :                 }                                                                                                                                            
     820               0 :                 if (isset($_SERVER['SCRIPT_NAME'])) {                                                                                                        
     821               0 :                     $reportData['script_name'] = $_SERVER['SCRIPT_NAME'];                                                                                    
     822               0 :                 }                                                                                                                                            
     823               0 :             }                                                                                                                                                
     824                 :                                                                                                                                                              
     825                 :             // attempt to specify store as a skin                                                                                                            
     826                 :             try {                                                                                                                                            
     827               0 :                 $storeCode = self::app()->getStore()->getCode();                                                                                             
     828               0 :                 $reportData['skin'] = $storeCode;                                                                                                            
     829                 :             }                                                                                                                                                
     830               0 :             catch (Exception $e) {}                                                                                                                          
     831                 :                                                                                                                                                              
     832               0 :             require_once(self::getBaseDir() . DS . 'errors' . DS . 'report.php');                                                                            
     833                 :         }                                                                                                                                                    
     834                 :                                                                                                                                                              
     835               0 :         die();                                                                                                                                               
     836                 :     }                                                                                                                                                        
     837                 :                                                                                                                                                              
     838                 :     /**                                                                                                                                                      
     839                 :      * Define system folder directory url by virtue of running script directory name                                                                         
     840                 :      * Try to find requested folder by shifting to domain root directory                                                                                     
     841                 :      *                                                                                                                                                       
     842                 :      * @param   string  $folder                                                                                                                              
     843                 :      * @param   boolean $exitIfNot                                                                                                                           
     844                 :      * @return  string                                                                                                                                       
     845                 :      */                                                                                                                                                      
     846                 :     public static function getScriptSystemUrl($folder, $exitIfNot = false)                                                                                   
     847                 :     {                                                                                                                                                        
     848               0 :         $runDirUrl  = rtrim(dirname($_SERVER['SCRIPT_NAME']), '/');                                                                                          
     849               0 :         $runDir     = rtrim(dirname($_SERVER['SCRIPT_FILENAME']), DS);                                                                                       
     850                 :                                                                                                                                                              
     851               0 :         $baseUrl    = null;                                                                                                                                  
     852               0 :         if (is_dir($runDir.'/'.$folder)) {                                                                                                                   
     853               0 :             $baseUrl = str_replace(DS, '/', $runDirUrl);                                                                                                     
     854               0 :         } else {                                                                                                                                             
     855               0 :             $runDirUrlArray = explode('/', $runDirUrl);                                                                                                      
     856               0 :             $runDirArray    = explode('/', $runDir);                                                                                                         
     857               0 :             $count          = count($runDirArray);                                                                                                           
     858                 :                                                                                                                                                              
     859               0 :             for ($i=0; $i < $count; $i++) {                                                                                                                  
     860               0 :                 array_pop($runDirUrlArray);                                                                                                                  
     861               0 :                 array_pop($runDirArray);                                                                                                                     
     862               0 :                 $_runDir = implode('/', $runDirArray);                                                                                                       
     863               0 :                 if (!empty($_runDir)) {                                                                                                                      
     864               0 :                     $_runDir .= '/';                                                                                                                         
     865               0 :                 }                                                                                                                                            
     866                 :                                                                                                                                                              
     867               0 :                 if (is_dir($_runDir.$folder)) {                                                                                                              
     868               0 :                     $_runDirUrl = implode('/', $runDirUrlArray);                                                                                             
     869               0 :                     $baseUrl    = str_replace(DS, '/', $_runDirUrl);                                                                                         
     870               0 :                     break;                                                                                                                                   
     871                 :                 }                                                                                                                                            
     872               0 :             }                                                                                                                                                
     873                 :         }                                                                                                                                                    
     874                 :                                                                                                                                                              
     875               0 :         if (is_null($baseUrl)) {                                                                                                                             
     876               0 :             $errorMessage = "Unable detect system directory: $folder";                                                                                       
     877               0 :             if ($exitIfNot) {                                                                                                                                
     878                 :                 // exit because of infinity loop                                                                                                             
     879               0 :                 exit($errorMessage);                                                                                                                         
     880                 :             } else {                                                                                                                                         
     881               0 :                 self::printException(new Exception(), $errorMessage);                                                                                        
     882                 :             }                                                                                                                                                
     883               0 :         }                                                                                                                                                    
     884                 :                                                                                                                                                              
     885               0 :         return $baseUrl;                                                                                                                                     
     886                 :     }                                                                                                                                                        
     887                 :                                                                                                                                                              
     888                 :     /**                                                                                                                                                      
     889                 :      * Set is downloader flag                                                                                                                                
     890                 :      *                                                                                                                                                       
     891                 :      * @param bool $flag                                                                                                                                     
     892                 :      */                                                                                                                                                      
     893                 :     public static function setIsDownloader($flag = true)                                                                                                     
     894                 :     {                                                                                                                                                        
     895               0 :         self::$_isDownloader = $flag;                                                                                                                        
     896               0 :     }                                                                                                                                                        
     897                 : }                                                                                                                                                            

Generated by PHP_CodeCoverage 1.0.4 using PHP 5.3.4 and PHPUnit 3.5.13 at Tue Jul 5 9:07:16 UTC 2011.