Registry.php

Go to the documentation of this file.

<?php
// {{{ license

// +----------------------------------------------------------------------+
// | FastFrame Application Framework                                      |
// +----------------------------------------------------------------------+
// | Copyright (c) 2002-2006 The Codejanitor Group                        |
// +----------------------------------------------------------------------+
// | This source file is subject to the GNU Lesser Public License (LGPL), |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.fsf.org/copyleft/lesser.html                              |
// | If you did not receive a copy of the LGPL and are unable to          |
// | obtain it through the world-wide-web, you can get it by writing the  |
// | Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, |
// | MA 02111-1307, USA.                                                  |
// +----------------------------------------------------------------------+
// | Authors: The Horde Team <http://www.horde.org>                       |
// |          Jason Rust <jrust@codejanitor.com>                          |
// |          Dan Allen <dan@mojavelinux.com>                             |
// +----------------------------------------------------------------------+

// }}}
// {{{ includes

require_once dirname(__FILE__) . '/Locale.php';

// }}}
// {{{ constants/globals

// types of filepaths that can be generated
define('FASTFRAME_WEBPATH',  1);
define('FASTFRAME_FILEPATH', 2);
define('FASTFRAME_DATAPATH', 3);

// the default application
define('FASTFRAME_DEFAULT_APP', 'fastframe');

// }}}
// {{{ class FF_Registry

// }}}
class FF_Registry {
    // {{{ properties

    var $apps = array();

    var $config = array();

    var $appStack = array();

    var $servicePaths = array(
        // names of the directories in the fastframe root
        'root_apps'       =>  'apps',
        'root_config'     =>  'config',
        'root_language'   =>  'locale',
        'root_libs'       =>  'lib',
        'root_javascript' =>  'js',
        'root_graphics'   =>  'graphics',
        'root_cache'      =>  'cache',
        'root_data'       =>  'data',
        'root_themes'     =>  'themes',
        // names of the services inside an app (%app% is the basename of the app)
        'app_libs'        => '%app%/lib',
        'app_graphics'    => '%app%/graphics',
        'app_javascript'  => '%app%/js',
        'app_language'    => '%app%/locale',
        'app_config'      => '%app%/config');

    // }}}
    // {{{ constructor

    function FF_Registry()
    {
        include_once FASTFRAME_ROOT . 'config/apps.php';
        $this->apps =& $apps;
        // Add the default app which might not be in the apps file
        // since it is sort of a pseudo app
        if (!isset($this->apps[FASTFRAME_DEFAULT_APP])) {
            $this->apps[FASTFRAME_DEFAULT_APP] = array();
        }

        // Don't set the language because it will run into an infinite loop otherwise,
        // since the Locale class uses the registry.
        $this->pushApp(FASTFRAME_DEFAULT_APP, false);

        // Initial FastFrame-wide settings
        // Set the error reporting level in accordance with the config settings.
        error_reporting($this->getConfigParam('error/debug_level'));

        // Set the maximum execution time in accordance with the config settings.
        @set_time_limit($this->getConfigParam('general/max_exec_time'));

        // Set the umask according to config settings
        if (!is_null($umask = $this->getConfigParam('general/umask'))) {
            umask($umask);
        }

        // All apps to be used must be included in the apps.php file
        foreach (array_keys($this->apps) as $s_name) {
            // Don't carry around disabled apps
            if (isset($this->apps[$s_name]['status']) && $this->apps[$s_name]['status'] == 'disabled') {
                unset($this->apps[$s_name]);
            }
        } 
    }

    // }}}
    // {{{ singleton()

    function &singleton()
    {
        static $instance;
        if (!isset($instance)) {
            $instance = new FF_Registry();
        }

        return $instance;
    }

    // }}}
    // {{{ importConfig()

    function importConfig($in_app = FASTFRAME_DEFAULT_APP)
    {
        // :NOTE: All fatal errors generated in this method should not be logged
        // since the log method calls getConfigParam() which could cause an infinite loop
        if (!isset($this->apps[$in_app])) {
            trigger_error("The application $in_app is not a defined application.  Check your apps.php file.", E_USER_ERROR);
        }

        // Now load the configuration for this specific app
        if (!isset($this->config[$in_app])) {
            if ($in_app == FASTFRAME_DEFAULT_APP) {
                include_once FASTFRAME_ROOT . 'config/conf.php';
            }
            else {
                // Look up which profile to use for the config files
                $s_configFile = isset($this->apps[$in_app]['profile']) ? 
                    $this->apps[$in_app]['profile'] . '/conf.php' : 'conf.php';
                $s_appDir = isset($this->apps[$in_app]['app_dir']) ?  $this->apps[$in_app]['app_dir'] : $in_app;
                $s_file = $this->getAppFile($s_configFile, $s_appDir, 'config');
                if (!is_file($s_file)) {
                    trigger_error('Could not import the config file ' . basename($s_file) . ' for the ' . $in_app . ' application', E_USER_ERROR);
                }
                else {
                    include_once $s_file;
                }
            }

            $this->config[$in_app] =& $conf;
        }
    }

    // }}}
    // {{{ setLocale()

    function setLocale($in_app = null)
    {
        if (is_null($in_app)) {
            $in_app = $this->getCurrentApp();
        }

        FF_Locale::setLang();
        if ($in_app == FASTFRAME_DEFAULT_APP) {
            FF_Locale::setTextdomain($in_app, $this->getRootFile('', 'language'), FF_Locale::getCharset());
        }
        else {
            FF_Locale::setTextdomain($in_app, $this->getAppFile('', $in_app, 'language'), FF_Locale::getCharset());
        }
    }

    // }}}
    // {{{ pushApp()

    function pushApp($in_app, $in_locale = true)
    {
        // If we are changing apps then we need to import config
        if ($in_app != $this->getCurrentApp()) {
            // Import the config for this application
            $this->importConfig($in_app);
            if ($in_locale) {
                $this->setLocale($in_app);
            }
        }

        // Now that we've checked if it's changed, push it on
        $this->appStack[] = $in_app;
    }

    // }}}
    // {{{ popCurrentApp()

    function popCurrentApp()
    {
        $s_currentApp = array_pop($this->appStack);
        $s_app = $this->getCurrentApp();
        // Import the new active application's configuration values again
        // if there is still at least one application on the stack
        if (!is_null($s_app) && $s_app != $s_currentApp) {
            $this->importConfig($s_app);
            $this->setLocale($s_app);
        }

        return $s_currentApp;
    }

    // }}}
    // {{{ getCurrentApp()

    function getCurrentApp()
    {
        return @end($this->appStack);
    }

    // }}}
    // {{{ getFile()

    function getFile($in_file, $in_type = FASTFRAME_FILEPATH)
    {
        $a_pathParts = array();
        // Given the number of times this is called and that it can be
        // called from getConfigParam() we access the config array directly
        switch ($in_type) {
            case FASTFRAME_WEBPATH:
                $a_pathParts = array($this->config[FASTFRAME_DEFAULT_APP]['webserver']['web_root']);
                break;
            case FASTFRAME_FILEPATH:
                $a_pathParts = array($this->config[FASTFRAME_DEFAULT_APP]['webserver']['file_root']);
                break;
            case FASTFRAME_DATAPATH:
                $a_pathParts = array($this->config[FASTFRAME_DEFAULT_APP]['webserver']['data_root']);
                break;
            default:
                break;
        }
        
        if (is_array($in_file)) {
            $a_pathParts = array_merge($a_pathParts, $in_file);
        }
        else {
            $a_pathParts[] = $in_file;
        }

        $s_path = implode('/', $a_pathParts);
        // It's important that there be no double slashes in web paths
        if ($in_type == FASTFRAME_WEBPATH) {
            $s_path = str_replace('//', '/', $s_path);
        }
        
        return $s_path;
    }

    // }}}
    // {{{ getAppFile()

    function getAppFile($in_filename, $in_app = null, $in_service = '', $in_type = FASTFRAME_FILEPATH)
    {
        // this is how we handle the root path to the app 
        if (FastFrame::isEmpty($in_service)) {
            $s_service = '%app%';
        }
        elseif (isset($this->servicePaths['app_' . $in_service])) {
            $s_service = $this->servicePaths['app_' . $in_service];
        }
        else {
            trigger_error("The app service 'app_$in_service' could not be found.", E_USER_ERROR); 
        }

        $s_app = !is_null($in_app) ? $in_app : $this->getCurrentApp();

        // Use the app name as the apps directory unless the user has 
        // overriden it in apps.php
        $s_appDir = str_replace('%app%', $this->getAppParam('app_dir', $s_app, $s_app), $s_service);
        return $this->getFile(array($this->servicePaths['root_apps'], $s_appDir, $in_filename), $in_type);
    }

    // }}}
    // {{{ getRootFile()

    function getRootFile($in_filename, $in_service = '', $in_type = FASTFRAME_FILEPATH)
    {
        if (!empty($in_service) && !isset($this->servicePaths['root_' . $in_service])) {
            trigger_error("The service root_$in_service could not be found", E_USER_ERROR); 
        }

        return $this->getFile(array($this->servicePaths['root_' . $in_service], $in_filename), $in_type);
    }

    // }}}
    // {{{ getAppParam()

    function getAppParam($in_param, $in_default = null, $in_app = null)
    {
        $in_app = is_null($in_app) ? $this->getCurrentApp() : $in_app;
        return isset($this->apps[$in_app][$in_param]) ? $this->apps[$in_app][$in_param] : $in_default;
    }

    // }}}
    // {{{ getConfigParam()

    function getConfigParam($in_paramPath, $in_default = null, $in_app = null) 
    {
        $in_app = is_null($in_app) ? $this->getCurrentApp() : $in_app;
        // Import the config for this app if it has not yet beeen imported 
        if (!isset($this->config[$in_app])) {
            $this->importConfig($in_app);
        }

        list($tmp1, $tmp2) = explode('/', $in_paramPath);
        if ($tmp2 == '*') {
            return isset($this->config[$in_app][$tmp1]) ? 
                $this->config[$in_app][$tmp1] :
                (isset($this->config[FASTFRAME_DEFAULT_APP][$tmp1]) ?
                 $this->config[FASTFRAME_DEFAULT_APP][$tmp1] : $in_default);
        }
        else {
            return isset($this->config[$in_app][$tmp1][$tmp2]) ? 
                $this->config[$in_app][$tmp1][$tmp2] :
                (isset($this->config[FASTFRAME_DEFAULT_APP][$tmp1][$tmp2]) ?
                 $this->config[FASTFRAME_DEFAULT_APP][$tmp1][$tmp2] : $in_default);
        }
    }

    // }}}
    // {{{ getApps()

    function getApps()
    {
        $a_apps = array();
        foreach ($this->apps as $s_app => $a_vals) {
            $a_apps[] = $s_app;
        }

        return $a_apps;
    }

    // }}}
    // {{{ hasApp()

    function hasApp($in_app)
    {
        if (isset($this->apps[$in_app]) &&
            isset($this->apps[$in_app]['status']) &&
            $this->apps[$in_app]['status'] != 'disabled') {
            return true;
        }
        else {
            return false;
        }
    }

    // }}}
    // {{{ rootPathToWebPath()

    function rootPathToWebPath($in_path)
    {
        $s_fileRoot = $this->getConfigParam('webserver/file_root');
        if (strpos($in_path, $s_fileRoot) === 0) {
            return substr_replace($in_path, $this->getConfigParam('webserver/web_root'), 0, strlen($s_fileRoot));
        }
        else {
            return $in_path;
        }
    }

    // }}}
}
?>

---