Slim.php

Go to the documentation of this file.

<?php
//Ensure PHP session IDs only use the characters [a-z0-9]
ini_set('session.hash_bits_per_character', 4);
ini_set('session.hash_function', 0);
 
//Slim's Encryted Cookies rely on libmcyrpt and these two constants.
//If libmycrpt is unavailable, we ensure the expected constants
//are available to avoid errors.
if ( !defined('MCRYPT_RIJNDAEL_256') ) {
    define('MCRYPT_RIJNDAEL_256', 0);
}
if ( !defined('MCRYPT_MODE_CBC') ) {
    define('MCRYPT_MODE_CBC', 0);
}
 
//This determines which errors are reported by PHP. By default, all
//errors (including E_STRICT) are reported.
//error_reporting(E_ALL | E_STRICT);
 
//This tells PHP to auto-load classes using Slim's autoloader; this will
//only auto-load a class file located in the same directory as Slim.php
//whose file name (excluding the final dot and extension) is the same
//as its class name (case-sensitive). For example, "View.php" will be
//loaded when Slim uses the "View" class for the first time.
spl_autoload_register(array('Slim', 'autoload'));
 
//PHP 5.3 will complain if you don't set a timezone. If you do not
//specify your own timezone before requiring Slim, this tells PHP to use UTC.
if ( @date_default_timezone_set(date_default_timezone_get()) === false ) {
    date_default_timezone_set('UTC');
}
 
class Slim {
 
    protected static $apps = array();
 
    protected $name;
 
    protected $request;
 
    protected $response;
 
    protected $router;
 
    protected $view;
 
    protected $log;
 
    protected $settings;
 
    protected $mode;
 
    protected $hooks = array(
        'slim.before' => array(array()),
        'slim.before.router' => array(array()),
        'slim.before.dispatch' => array(array()),
        'slim.after.dispatch' => array(array()),
        'slim.after.router' => array(array()),
        'slim.after' => array(array())
    );
 
    public static function autoload( $class ) {
        if ( strpos($class, 'Slim') !== 0 ) {
            return;
        }
        $file = dirname(__FILE__) . '/' . str_replace('_', DIRECTORY_SEPARATOR, substr($class,5)) . '.php';
        if ( file_exists($file) ) {
            require $file;
        }
    }
 
    /***** INITIALIZATION *****/
 
    public function __construct( $userSettings = array() ) {
        //Merge application settings
        $this->settings = array_merge(array(
            //Mode
            'mode' => 'development',
            //Logging
            'log.enable' => false,
            'log.logger' => null,
            'log.path' => './logs',
            'log.level' => 4,
            //Debugging
            'debug' => true,
            //View
            'templates.path' => './templates',
            'view' => 'Slim_View',
            //Settings for all cookies
            'cookies.lifetime' => '20 minutes',
            'cookies.path' => '/',
            'cookies.domain' => '',
            'cookies.secure' => false,
            'cookies.httponly' => false,
            //Settings for encrypted cookies
            'cookies.secret_key' => 'CHANGE_ME',
            'cookies.cipher' => MCRYPT_RIJNDAEL_256,
            'cookies.cipher_mode' => MCRYPT_MODE_CBC,
            'cookies.encrypt' => true,
            'cookies.user_id' => 'DEFAULT',
            //Session handler
            'session.handler' => new Slim_Session_Handler_Cookies(),
            'session.flash_key' => 'flash',
            //HTTP
            'http.version' => null
        ), $userSettings);
 
        //Determine application mode
        $this->getMode();
 
        //Setup HTTP request and response handling
        $this->request = new Slim_Http_Request();
        $this->response = new Slim_Http_Response($this->request);
        $this->response->setCookieJar(new Slim_Http_CookieJar($this->settings['cookies.secret_key'], array(
            'high_confidentiality' => $this->settings['cookies.encrypt'],
            'mcrypt_algorithm' => $this->settings['cookies.cipher'],
            'mcrypt_mode' => $this->settings['cookies.cipher_mode'],
            'enable_ssl' => $this->settings['cookies.secure']
        )));
        $this->response->httpVersion($this->settings['http.version']);
        $this->router = new Slim_Router($this->request);
 
        //Start session if not already started
        if ( session_id() === '' ) {
            $sessionHandler = $this->config('session.handler');
            if ( $sessionHandler instanceof Slim_Session_Handler ) {
                $sessionHandler->register($this);
            }
            session_cache_limiter(false); 
            session_start();
        }
 
        //Setup view with flash messaging
        $this->view($this->config('view'))->setData('flash', new Slim_Session_Flash($this->config('session.flash_key')));
 
        //Set app name
        if ( !isset(self::$apps['default']) ) {
            $this->setName('default');
        }
 
        //Set global Error handler after Slim app instantiated
        set_error_handler(array('Slim', 'handleErrors'));
    }
 
    public function getMode() {
        if ( !isset($this->mode) ) {
            if ( isset($_ENV['SLIM_MODE']) ) {
                $this->mode = (string)$_ENV['SLIM_MODE'];
            } else {
                $envMode = getenv('SLIM_MODE');
                if ( $envMode !== false ) {
                    $this->mode = $envMode;
                } else {
                    $this->mode = (string)$this->config('mode');
                }
            }
        }
        return $this->mode;
    }
 
    /***** NAMING *****/
 
    public static function getInstance( $name = 'default' ) {
        return isset(self::$apps[(string)$name]) ? self::$apps[(string)$name] : null;
    }
 
    public function setName( $name ) {
        $this->name = $name;
        self::$apps[$name] = $this;
    }
 
    public function getName() {
        return $this->name;
    }
 
    /***** LOGGING *****/
 
    public function getLog() {
        if ( !isset($this->log) ) {
            $this->log = new Slim_Log();
            $this->log->setEnabled($this->config('log.enable'));
            $logger = $this->config('log.logger');
            if ( $logger ) {
                $this->log->setLogger($logger);
            } else {
                $this->log->setLogger(new Slim_Logger($this->config('log.path'), $this->config('log.level')));
            }
        }
        return $this->log;
    }
 
    /***** CONFIGURATION *****/
 
    public function configureMode( $mode, $callable ) {
        if ( $mode === $this->getMode() && is_callable($callable) ) {
            call_user_func($callable);
        }
    }
 
    public function config( $name, $value = null ) {
        if ( func_num_args() === 1 ) {
            if ( is_array($name) ) {
                $this->settings = array_merge($this->settings, $name);
            } else {
                return in_array($name, array_keys($this->settings)) ? $this->settings[$name] : null;
            }
        } else {
            $this->settings[$name] = $value;
        }
    }
 
    /***** ROUTING *****/
 
    protected function mapRoute($args) {
        $pattern = array_shift($args);
        $callable = array_pop($args);
        $route = $this->router->map($pattern, $callable);
        if ( count($args) > 0 ) {
            $route->setMiddleware($args);
        }
        return $route;
    }
 
    public function map() {
        $args = func_get_args();
        return $this->mapRoute($args);
    }
 
    public function get() {
        $args = func_get_args();
        return $this->mapRoute($args)->via(Slim_Http_Request::METHOD_GET, Slim_Http_Request::METHOD_HEAD);
    }
 
    public function post() {
        $args = func_get_args();
        return $this->mapRoute($args)->via(Slim_Http_Request::METHOD_POST);
    }
 
    public function put() {
        $args = func_get_args();
        return $this->mapRoute($args)->via(Slim_Http_Request::METHOD_PUT);
    }
 
    public function delete() {
        $args = func_get_args();
        return $this->mapRoute($args)->via(Slim_Http_Request::METHOD_DELETE);
    }
 
    public function options() {
        $args = func_get_args();
        return $this->mapRoute($args)->via(Slim_Http_Request::METHOD_OPTIONS);
    }
 
    public function notFound( $callable = null ) {
        if ( !is_null($callable) ) {
            $this->router->notFound($callable);
        } else {
            ob_start();
            $customNotFoundHandler = $this->router->notFound();
            if ( is_callable($customNotFoundHandler) ) {
                call_user_func($customNotFoundHandler);
            } else {
                call_user_func(array($this, 'defaultNotFound'));
            }
            $this->halt(404, ob_get_clean());
        }
    }
 
    public function error( $argument = null ) {
        if ( is_callable($argument) ) {
            //Register error handler
            $this->router->error($argument);
        } else {
            //Invoke error handler
            ob_start();
            $customErrorHandler = $this->router->error();
            if ( is_callable($customErrorHandler) ) {
                call_user_func_array($customErrorHandler, array($argument));
            } else {
                call_user_func_array(array($this, 'defaultError'), array($argument));
            }
            $this->halt(500, ob_get_clean());
        }
    }
 
    /***** ACCESSORS *****/
 
    public function request() {
        return $this->request;
    }
 
    public function response() {
        return $this->response;
    }
 
    public function router() {
        return $this->router;
    }
 
    public function view( $viewClass = null ) {
        if ( !is_null($viewClass) ) {
            $existingData = is_null($this->view) ? array() : $this->view->getData();
            if ( $viewClass instanceOf Slim_View ) {
                $this->view = $viewClass;
            } else {
                $this->view = new $viewClass();
            }
            $this->view->appendData($existingData);
            $this->view->setTemplatesDirectory($this->config('templates.path'));
        }
        return $this->view;
    }
 
    /***** RENDERING *****/
 
    public function render( $template, $data = array(), $status = null ) {
        if ( !is_null($status) ) {
            $this->response->status($status);
        }
        $this->view->appendData($data);
        $this->view->display($template);
    }
 
    /***** HTTP CACHING *****/
 
    public function lastModified( $time ) {
        if ( is_integer($time) ) {
            $this->response->header('Last-Modified', date(DATE_RFC1123, $time));
            if ( $time === strtotime($this->request->headers('IF_MODIFIED_SINCE')) ) $this->halt(304);
        } else {
            throw new InvalidArgumentException('Slim::lastModified only accepts an integer UNIX timestamp value.');
        }
    }
 
    public function etag( $value, $type = 'strong' ) {
 
        //Ensure type is correct
        if ( !in_array($type, array('strong', 'weak')) ) {
            throw new InvalidArgumentException('Invalid Slim::etag type. Expected "strong" or "weak".');
        }
 
        //Set etag value
        $value = '"' . $value . '"';
        if ( $type === 'weak' ) $value = 'W/'.$value;
        $this->response->header('ETag', $value);
 
        //Check conditional GET
        if ( $etagsHeader = $this->request->headers('IF_NONE_MATCH')) {
            $etags = preg_split('@\s*,\s*@', $etagsHeader);
            if ( in_array($value, $etags) || in_array('*', $etags) ) $this->halt(304);
        }
 
    }
 
    /***** COOKIES *****/
 
    public function setCookie( $name, $value, $time = null, $path = null, $domain = null, $secure = null, $httponly = null ) {
        $time = is_null($time) ? $this->config('cookies.lifetime') : $time;
        $path = is_null($path) ? $this->config('cookies.path') : $path;
        $domain = is_null($domain) ? $this->config('cookies.domain') : $domain;
        $secure = is_null($secure) ? $this->config('cookies.secure') : $secure;
        $httponly = is_null($httponly) ? $this->config('cookies.httponly') : $httponly;
        $this->response->getCookieJar()->setClassicCookie($name, $value, $time, $path, $domain, $secure, $httponly);
    }
 
    public function getCookie( $name ) {
        return $this->request->cookies($name);
    }
 
    public function setEncryptedCookie( $name, $value, $time = null, $path = null, $domain = null, $secure = null, $httponly = null ) {
        $time = is_null($time) ? $this->config('cookies.lifetime') : $time;
        $path = is_null($path) ? $this->config('cookies.path') : $path;
        $domain = is_null($domain) ? $this->config('cookies.domain') : $domain;
        $secure = is_null($secure) ? $this->config('cookies.secure') : $secure;
        $httponly = is_null($httponly) ? $this->config('cookies.httponly') : $httponly;
        $userId = $this->config('cookies.user_id');
        $this->response->getCookieJar()->setCookie($name, $value, $userId, $time, $path, $domain, $secure, $httponly);
    }
 
    public function getEncryptedCookie( $name ) {
        $value = $this->response->getCookieJar()->getCookieValue($name);
        return ($value === false) ? null : $value;
    }
 
    public function deleteCookie( $name, $path = null, $domain = null, $secure = null, $httponly = null ) {
        $path = is_null($path) ? $this->config('cookies.path') : $path;
        $domain = is_null($domain) ? $this->config('cookies.domain') : $domain;
        $secure = is_null($secure) ? $this->config('cookies.secure') : $secure;
        $httponly = is_null($httponly) ? $this->config('cookies.httponly') : $httponly;
        $this->response->getCookieJar()->deleteCookie( $name, $path, $domain, $secure, $httponly );
    }
 
    /***** HELPERS *****/
 
    public function root() {
        return rtrim($_SERVER['DOCUMENT_ROOT'], '/') . rtrim($this->request->getRootUri(), '/') . '/';
    }
 
    public function stop() {
        $flash = $this->view->getData('flash');
        if ( $flash ) {
            $flash->save();
        }
        session_write_close();
        $this->response->send();
        throw new Slim_Exception_Stop();
    }
 
    public function halt( $status, $message = '') {
        if ( ob_get_level() !== 0 ) {
            ob_clean();
        }
        $this->response->status($status);
        $this->response->body($message);
        $this->stop();
    }
 
    public function pass() {
        if ( ob_get_level() !== 0 ) {
            ob_clean();
        }
        throw new Slim_Exception_Pass();
    }
 
    public function contentType( $type ) {
        $this->response->header('Content-Type', $type);
    }
 
    public function status( $code ) {
        $this->response->status($code);
    }
 
    public function urlFor( $name, $params = array() ) {
        return $this->router->urlFor($name, $params);
    }
 
    public function redirect( $url, $status = 302 ) {
        if ( $status >= 300 && $status <= 307 ) {
            $this->response->header('Location', (string)$url);
            $this->halt($status, (string)$url);
        } else {
            throw new InvalidArgumentException('Slim::redirect only accepts HTTP 300-307 status codes.');
        }
    }
 
    /***** FLASH *****/
 
    public function flash( $key, $value ) {
        $this->view->getData('flash')->set($key, $value);
    }
 
    public function flashNow( $key, $value ) {
        $this->view->getData('flash')->now($key, $value);
    }
 
    public function flashKeep() {
        $this->view->getData('flash')->keep();
    }
 
    /***** HOOKS *****/
 
    public function hook( $name, $callable, $priority = 10 ) {
        if ( !isset($this->hooks[$name]) ) {
            $this->hooks[$name] = array(array());
        }
        if ( is_callable($callable) ) {
            $this->hooks[$name][(int)$priority][] = $callable;
        }
    }
 
    public function applyHook( $name, $hookArg = null ) {
        if ( !isset($this->hooks[$name]) ) {
            $this->hooks[$name] = array(array());
        }
        if( !empty($this->hooks[$name]) ) {
            // Sort by priority, low to high, if there's more than one priority
            if ( count($this->hooks[$name]) > 1 ) {
                ksort($this->hooks[$name]);
            }
            foreach( $this->hooks[$name] as $priority ) {
                if( !empty($priority) ) {
                    foreach($priority as $callable) {
                        $hookArg = call_user_func($callable, $hookArg);
                    }
                }
            }
            return $hookArg;
        }
    }
 
    public function getHooks( $name = null ) {
        if ( !is_null($name) ) {
            return isset($this->hooks[(string)$name]) ? $this->hooks[(string)$name] : null;
        } else {
            return $this->hooks;
        }
    }
 
    public function clearHooks( $name = null ) {
        if ( !is_null($name) && isset($this->hooks[(string)$name]) ) {
            $this->hooks[(string)$name] = array(array());
        } else {
            foreach( $this->hooks as $key => $value ) {
                $this->hooks[$key] = array(array());
            }
        }
    }
 
    /***** RUN SLIM *****/
 
    public function run() {
        try {
            try {
                $this->applyHook('slim.before');
                ob_start();
                $this->applyHook('slim.before.router');
                $dispatched = false;
                $httpMethod = $this->request()->getMethod();
                $httpMethodsAllowed = array();
                foreach ( $this->router as $route ) {
                    if ( $route->supportsHttpMethod($httpMethod) ) {
                        try {
                            $this->applyHook('slim.before.dispatch');
                            $dispatched = $route->dispatch();
                            $this->applyHook('slim.after.dispatch');
                            if ( $dispatched ) {
                                break;
                            }
                        } catch ( Slim_Exception_Pass $e ) {
                            continue;
                        }
                    } else {
                        $httpMethodsAllowed = array_merge($httpMethodsAllowed, $route->getHttpMethods());
                    }
                }
                if ( !$dispatched ) {
                    if ( $httpMethodsAllowed ) {
                        $this->response()->header('Allow', implode(' ', $httpMethodsAllowed));
                        $this->halt(405);
                    } else {
                        $this->notFound();
                    }
                }
                $this->response()->write(ob_get_clean());
                $this->applyHook('slim.after.router');
                $this->view->getData('flash')->save();
                session_write_close();
                $this->response->send();
                $this->applyHook('slim.after');
            } catch ( Slim_Exception_RequestSlash $e ) {
                $this->redirect($this->request->getRootUri() . $this->request->getResourceUri() . '/', 301);
            } catch ( Exception $e ) {
                if ( $e instanceof Slim_Exception_Stop ) throw $e;
                $this->getLog()->error($e);
                if ( $this->config('debug') === true ) {
                    $this->halt(500, self::generateErrorMarkup($e->getMessage(), $e->getFile(), $e->getLine(), $e->getTraceAsString()));
                } else {
                    $this->error($e);
                }
            }
        } catch ( Slim_Exception_Stop $e ) {
            //Exit application context
        }
    }
 
    /***** EXCEPTION AND ERROR HANDLING *****/
 
    public static function handleErrors( $errno, $errstr = '', $errfile = '', $errline = '' ) {
        if ( error_reporting() & $errno ) {
            throw new ErrorException($errstr, $errno, 0, $errfile, $errline);
        }
        return true;
    }
 
    protected static function generateErrorMarkup( $message, $file = '', $line = '', $trace = '' ) {
        $body = '<p>The application could not run because of the following error:</p>';
        $body .= "<h2>Details:</h2><strong>Message:</strong> $message<br/>";
        if ( $file !== '' ) $body .= "<strong>File:</strong> $file<br/>";
        if ( $line !== '' ) $body .= "<strong>Line:</strong> $line<br/>";
        if ( $trace !== '' ) $body .= '<h2>Stack Trace:</h2>' . nl2br($trace);
        return self::generateTemplateMarkup('Slim Application Error', $body);
    }
 
    protected static function generateTemplateMarkup( $title, $body ) {
        $html = "<html><head><title>$title</title><style>body{margin:0;padding:30px;font:12px/1.5 Helvetica,Arial,Verdana,sans-serif;}h1{margin:0;font-size:48px;font-weight:normal;line-height:48px;}strong{display:inline-block;width:65px;}</style></head><body>";
        $html .= "<h1>$title</h1>";
        $html .= $body;
        $html .= '</body></html>';
        return $html;
    }
 
    protected function defaultNotFound() {
        echo self::generateTemplateMarkup('404 Page Not Found', '<p>The page you are looking for could not be found. Check the address bar to ensure your URL is spelled correctly. If all else fails, you can visit our home page at the link below.</p><a href="' . $this->request->getRootUri() . '">Visit the Home Page</a>');
    }
 
    protected function defaultError() {
        echo self::generateTemplateMarkup('Error', '<p>A website error has occured. The website administrator has been notified of the issue. Sorry for the temporary inconvenience.</p>');
    }
 
}