source/lib/simplicity/simplicity.php

   1 <?php
   2 require_once 'core/pluggable/pluggable.php';
   3
   4 /**
   5  * Simplicity
   6  *
   7  * The main public interface of the Simplicity Framework. This class bootstraps your application and manages and executes the module chain.
   8  *
   9  *
  10  * @author John Le Drew <jp@antz29.com>
  11  * @copyright Copyright (c) 2009, John Le Drew
  12  * @license http://www.opensource.org/licenses/mit-license.php MIT License
  13  * @version 2.0.0-alpha
  14  *
  15  * @see smp_Tapped
  16  */
  17 class Simplicity extends smp_Pluggable {
  18
  19         static private $_instance;
  20
  21         private $_options = array(
  22                 'tapped_cache' => 0,
  23                 'config_backend' => 'Array',
  24                 'config_backend_options' => array(
  25                         'root' => '{APP}config'
  26                         )
  27                         );
  28
  29                         /**
  30                          * Config driver instance
  31                          *
  32                          * @var smp_ConfigDriver
  33                          */
  34                         private $_config;
  35
  36                         private $_lib;
  37                         private $_root;
  38                         private $_app;
  39
  40                         private $_modules = array();
  41
  42                         private $_last_module = false;
  43
  44                         private $_base = array();
  45                         private $_chains = array();
  46                         private $_chain = array();
  47
  48                         private $_alias = array();
  49
  50                         /**
  51                          * Returns the single Simplicity instance.
  52                          *
  53                          * @return Simplicity
  54                          */
  55                         static public function getInstance()
  56                         {
  57                                 if (!(self::$_instance instanceof Simplicity))
  58                                 {
  59                                         self::$_instance = new Simplicity();
  60                                 }
  61                                 return self::$_instance;
  62                         }
  63
  64                         private function __clone() {}
  65                         private function __construct() {}
  66
  67                         /**
  68                          * Sets any runtime options for the Simplicity framework.
  69                          *
  70                          * @param $options array An associative array of options to configure Simplicity.
  71                          *
  72                          * @return Simplicity
  73                          */
  74                         public function setOptions(array $options = array())
  75                         {
  76                                 $this->_options = array_merge($this->_options,$options);
  77                                 return $this;
  78                         }
  79
  80                         /**
  81                          * Initialises the Simplicity framework
  82                          *
  83                          * @return Simplicity
  84                          */
  85                         public function init()
  86                         {
  87                                 $this->initEnvironment();
  88                                 $this->initArchive();
  89                                 $this->initTapped();
  90
  91                                 smp_Enviroment::init();
  92                                 smp_Request::init();
  93
  94                                 $accept = smp_Request::getInstance()->getHeader('accept');
  95                                 $accept = is_array($accept) ? $accept[0] : $accept;
  96                                 smp_Response::getInstance()->setHeader('content-type',$accept);
  97
  98                                 $this->createExtensionPoint('smp_Module','dynamic');
  99                                 $this->registerPluginPrefix('smp_','dynamic');
 100
 101                                 $this->createExtensionPoint('smp_ModuleStatic','static');
 102                                 $this->registerPluginPrefix('smp_','static');
 103
 104                                 $this->initConfig();
 105
 106                                 return $this;
 107                         }
 108
 109                         /**
 110                          * Executes the module chain(s) and dies.
 111                          *
 112                          */
 113                         public function run()
 114                         {
 115                                 $chains = array();
 116
 117                                 $this->_alias = $this->_config->get('modules.alias');
 118                                 $this->_chains = $this->_config->get('modules.chains');
 119
 120                                 $chains = array(
 121                         '_static' => array(
 122                                 'chain' => array('Static'),
 123                                 'match' => '/_static/*',
 124                                 'nobase' => true
 125                                 )
 126                                 );
 127
 128                                 $this->_chains = is_array($this->_chains) ? $this->_chains : array();
 129                                 $this->_chains = array_merge($chains,$this->_chains);
 130
 131                                 $this->_base = isset($this->_chains['_base']['chain']) ? $this->_chains['_base']['chain'] : array();
 132
 133                                 unset($this->_chains['_base']);
 134
 135                                 $match = false;
 136                                 foreach ($this->_chains as $name => $chain)
 137                                 {
 138                                         if (!isset($chain['match']))
 139                                         {
 140                                                 $this->runChain($name);
 141                                                 break;
 142                                         }
 143                                         elseif (isset($chain['match']) && smp_Request::getInstance()->uriMatch($chain['match']))
 144                                         {
 145                                                 $this->runChain($name);
 146                                                 break;
 147                                         }
 148                                 }
 149
 150                                 smp_Response::getInstance()->sendStatus();
 151                                 smp_Response::getInstance()->sendHeaders();
 152                                 smp_Response::getInstance()->sendContent();
 153
 154                                 die();
 155                         }
 156
 157                         public function runChain($chain)
 158                         {
 159                                 if (!isset($this->_chains[$chain])) throw new smp_Exception("Chain {$chain} does not exist.");
 160                                 $chain = $this->_chains[$chain];
 161
 162                                 if (isset($chain['chain']) && is_array($chain['chain'])) {
 163                                         $this->_chain = (isset($chain['chain']) && is_array($chain['chain'])) ? $chain['chain'] : array();
 164                                 }
 165
 166                                 if (!isset($chain['nobase']) || !$chain['nobase']) {
 167                                         $this->_chain = array_merge($this->_base,$this->_chain);
 168                                 }
 169
 170                                 $output = array();
 171
 172                                 while($module = array_shift($this->_chain)) {
 173                                         $output = $this->runModule($module,$output);
 174                                 }
 175                         }
 176
 177                         /**
 178                          * Executed the specified $module identifier and an array of arguments. Module identifiers take the format of alias or alias:method.
 179                          *
 180                          * @param $module
 181                          * @param $args
 182                          * @return array
 183                          */
 184                         public function runModule($module,$args=array())
 185                         {
 186                                 $module = explode(':',$module,2);
 187                                 $method = isset($module[1]) ? $module[1] : 'exec';
 188                                 $module = $module[0];
 189
 190                                 $module = $this->getModuleAlias($module);
 191
 192                                 if ($class = $this->getModuleClass($module,'dynamic')) {
 193                                         $mod = $this->getModule($module);
 194
 195                                         ob_start();
 196                                         $args = $mod->$method($args);
 197                                         smp_Response::getInstance()->addContent(ob_get_clean());
 198
 199                                         $this->_last_module = $module;
 200
 201                                         while($next_mod = $mod->getNext())
 202                                         {
 203                                                 $args = $this->runModule($next_mod,$args);
 204                                         }
 205
 206                                         return $args;
 207                                 }
 208                                 else
 209                                 {
 210                                         throw new Exception("Module {$module} could not be found!");
 211                                 }
 212                         }
 213
 214                         /**
 215                          * Clears the current module chain.
 216                          *
 217                          */
 218                         public function clearCurrentChain()
 219                         {
 220                                 $this->_chain = array();
 221                         }
 222
 223                         /**
 224                          * Adds a module identifier to the current chain.
 225                          *
 226                          * @param $module
 227                          */
 228                         public function addModuleToChain($module)
 229                         {
 230                                 $this->_chain[] = $module;
 231                         }
 232
 233                         /**
 234                          * Returns the last executed module identifier.
 235                          *
 236                          * @return string
 237                          */
 238                         public function getLastModule()
 239                         {
 240                                 return $this->_last_module;
 241                         }
 242
 243                         /**
 244                          * Return the module for the given $alias.
 245                          *
 246                          * @param $alias
 247                          * @return string
 248                          */
 249                         public function getModuleAlias($alias)
 250                         {
 251                                 return isset($this->_alias[$alias]) ? $this->_alias[$alias] : $alias;
 252                         }
 253
 254                         /**
 255                          * Instanciate and return an instance of the given module $alias. Optionally, only return the module class name by passing boolean
 256                          * boolean true on the second parameter.
 257                          *
 258                          * @param $alias string
 259                          * @param $class_only bool
 260                          * @return smp_Module|string
 261                          */
 262                         public function getModule($alias,$class_only=false)
 263                         {
 264                                 $module = $this->getModuleAlias($alias);
 265
 266                                 $class = $this->getModuleClass($module,'dynamic');
 267
 268                                 if ($class_only) return $class;
 269
 270                                 if (!isset($this->_modules[$alias]) || !($this->_modules[$alias] instanceof $class))
 271                                 {
 272                                         $this->_modules[$alias] = new $class($this,$alias);
 273                                 }
 274
 275                                 return $this->_modules[$alias];
 276                         }
 277
 278                         /**
 279                          * Gets the current shared config instance.
 280                          *
 281                          * @return smp_Config
 282                          */
 283                         public function getConfig()
 284                         {
 285                                 return $this->_config;
 286                         }
 287
 288                         /**
 289                          * Initialise the environment.
 290                          *
 291                          */
 292                         private function initEnvironment()
 293                         {
 294                                 ini_set('display_errors',1);
 295                                 error_reporting(-1);
 296
 297                                 define('DS',DIRECTORY_SEPARATOR);
 298                                 define('PS',PATH_SEPARATOR);
 299                                 date_default_timezone_set('UTC');
 300
 301                                 $this->_lib = dirname(dirname(dirname(__FILE__))).DS.'lib'.DS;
 302                                 $this->_app = dirname(dirname(dirname(__FILE__))).DS.'app'.DS;
 303                                 $this->_root = $this->_lib.'simplicity'.DS;
 304
 305                                 define('LIB',$this->_lib);
 306                                 define('APP',$this->_app);
 307                                 define('ROOT',$this->_root);
 308
 309                                 foreach ($this->_options as &$option) {
 310                                         $option = str_replace('{APP}',$this->_app,$option);
 311                                         $option = str_replace('{ROOT}',$this->_root,$option);
 312                                         $option = str_replace('{LIB}',$this->_lib,$option);
 313                                 }
 314                         }
 315
 316                         /**
 317                          * Initialise the smp_Archive support.
 318                          *
 319                          */
 320                         private function initArchive()
 321                         {
 322                                 $path = $this->_root.'core'.DS.'archive'.DS.'archive.php';
 323                                 require $path;
 324
 325                                 smp_Archive::init();
 326                         }
 327
 328                         /**
 329                          * Initialise the autoloader.
 330                          *
 331                          */
 332                         private function initTapped()
 333                         {
 334                                 $path = $this->_root.'core'.DS.'tapped'.DS.'tapped.php';
 335                                 require $path;
 336
 337                                 $t = smp_Tapped::getInstance()
 338                                 ->setCache($this->_options['tapped_cache'])
 339                                 ->addPath($this->_root);
 340
 341                                 if (file_exists($this->_app)) {
 342                                         $t->addPath($this->_app);
 343                                 }
 344
 345                                 $t->registerAutoloader();
 346                         }
 347
 348                         /**
 349                          * Initialise the configuration.
 350                          *
 351                          */
 352                         private function initConfig()
 353                         {
 354                                 $backend = $this->_options['config_backend'];
 355                                 $options = $this->_options['config_backend_options'];
 356                                 $options = is_array($options) ? $options : array();
 357
 358                                 $this->_config = new smp_Config($backend,$options);
 359                         }
 360 }