C:/xampp/htdocs/moodle/lib/yui/phploader/phploader/loader.php

Go to the documentation of this file.

<?PHP
define('YUI_AFTER',      'after');
define('YUI_BASE',       'base');
define('YUI_CSS',        'css');
define('YUI_DATA',       'DATA');
define('YUI_DEPCACHE',   'depCache');
define('YUI_DEBUG',      'DEBUG');
define('YUI_EMBED',      'EMBED');
define('YUI_FILTERS',    'filters');
define('YUI_FULLPATH',   'fullpath');
define('YUI_FULLJSON',   'FULLJSON');
define('YUI_GLOBAL',     'global');
define('YUI_JS',         'js');
define('YUI_JSON',       'JSON');
define('YUI_MODULES',    'modules');
define('YUI_SUBMODULES', 'submodules');
define('YUI_EXPOUND',    'expound');
define('YUI_NAME',       'name');
define('YUI_OPTIONAL',   'optional');
define('YUI_OVERRIDES',  'overrides');
define('YUI_PATH',       'path');
define('YUI_PKG',        'pkg');
define('YUI_PREFIX',     'prefix');
define('YUI_PROVIDES',   'provides');
define('YUI_RAW',        'RAW');
define('YUI_REPLACE',    'replace');
define('YUI_REQUIRES',   'requires');
define('YUI_ROLLUP',     'rollup');
define('YUI_SATISFIES',  'satisfies');
define('YUI_SEARCH',     'search');
define('YUI_SKIN',       'skin');
define('YUI_SKINNABLE',  'skinnable');
define('YUI_SUPERSEDES', 'supersedes');
define('YUI_TAGS',       'TAGS');
define('YUI_TYPE',       'type');
define('YUI_URL',        'url');


class YAHOO_util_Loader {
    
    var $base = "";

    var $filter = "";
    
    var $filters = array();
    
    var $filterList = null;

    var $allowRollups = true;

    var $loadOptional = false;

    var $rollupsToTop = false;

    var $processedModuleTypes = array();

    var $requests = array();

    var $loaded = array();

    var $superceded = array();

    var $undefined = array();
    
    var $dirty = true;
    
    var $sorted = null;
    
    var $accountedFor = array();

    var $skins = array();
    
    var $modules = array();

    var $fullCacheKey = null;

    var $baseOverrides = array();
    
    var $cacheFound = false;
    
    var $delayCache = false;
    
    /* If the version is set, a querystring parameter is appended to the
    * end of all generated URLs.  This is a cache busting hack for environments
    * that always use the same path for the current version of the library.
    * @property version
    * @type string
    * @default null
    */
    var $version = null;
    var $versionKey = "_yuiversion";

    /* Holds the calculated skin definition
    * @property skin
    * @type array
    * @default
    */
    var $skin = array();
    
    /* Holds the module rollup metadata
    * @property rollupModules
    * @type array
    * @default
    */
    var $rollupModules = array();
    
    /* Holds global module information.  Used for global dependency support.
    * Note: Does not appear to be in use by recent metadata.  Might be deprecated?
    * @property globalModules
    * @type array
    * @default
    */
    var $globalModules = array();
    
    /* Holds information about what modules satisfy the requirements of others
    * @property satisfactionMap
    * @type array
    * @default
    */
    var $satisfactionMap = array();
    
    /* Holds a cached module dependency list
    * @property depCache
    * @type array
    * @default
    */
    var $depCache = array();
    
    var $combine = false;

    var $comboBase = "http://yui.yahooapis.com/combo?";
    
    var $cssComboLocation = null;
    
    var $jsComboLocation  = null;

    function YAHOO_util_Loader($yuiVersion, $cacheKey=null, $modules=null, $noYUI=false) {
        if (!isset($yuiVersion)) {
            die("Error: The first parameter of YAHOO_util_Loader must specify which version of YUI to use!");
        }
        
        /* 
        * Include the metadata config file that corresponds to the requested YUI version
        * Note: we attempt to find a prebuilt config_{version}.php file which contains an associative array,
        * but if not available we'll attempt to find and parse the YUI json dependency file.
        */
        $parentDir = dirname(dirname(__FILE__));
        $phpConfigFile = $parentDir . '/lib/meta/config_' . $yuiVersion . '.php';
        $jsonConfigFile = $parentDir . '/lib/meta/json_' . $yuiVersion . '.txt';
        
        if (file_exists($phpConfigFile) && is_readable($phpConfigFile)) {
            require($phpConfigFile);
        } else if (file_exists($jsonConfigFile) && is_readable($jsonConfigFile) && function_exists('json_encode')) {
            $jsonConfigString = file_get_contents($jsonConfigFile);
            $inf = json_decode($jsonConfigString, true);
            $GLOBALS['yui_current'] = $inf;
        } else {
            die("Unable to find a suitable YUI metadata file!");
        }
        
        global $yui_current;

        $this->apcttl = 0;
        $this->curlAvail  = function_exists('curl_exec');
        $this->apcAvail   = function_exists('apc_fetch');
        $this->jsonAvail  = function_exists('json_encode');
        $this->customModulesInUse = empty($modules) ? false : true;
        $this->base = $yui_current[YUI_BASE];
        $this->comboDefaultVersion = $yuiVersion;
        $this->fullCacheKey = null;
        $cache = null;

        if ($cacheKey && $this->apcAvail) {
            $this->fullCacheKey = $this->base . $cacheKey;
            $cache = apc_fetch($this->fullCacheKey);
        } 
        
        if ($cache) {
            $this->cacheFound = true;
            $this->modules = $cache[YUI_MODULES];
            $this->skin = $cache[YUI_SKIN];
            $this->rollupModules = $cache[YUI_ROLLUP];
            $this->globalModules = $cache[YUI_GLOBAL];
            $this->satisfactionMap = $cache[YUI_SATISFIES];
            $this->depCache = $cache[YUI_DEPCACHE];
            $this->filters = $cache[YUI_FILTERS];
        } else {
            // set up the YUI info for the current version of the lib
            if ($noYUI) {
                $this->modules = array();
            } else {
                $this->modules = $yui_current['moduleInfo'];
            }

            if ($modules) {
                $this->modules = array_merge_recursive($this->modules, $modules);
            }

            $this->skin = $yui_current[YUI_SKIN];
            $this->skin['overrides'] = array();
            $this->skin[YUI_PREFIX] = "skin-";
            $this->filters = array(
                    YUI_RAW => array(
                            YUI_SEARCH => "/-min\.js/",
                            YUI_REPLACE => ".js"
                        ),
                    YUI_DEBUG => array(
                            YUI_SEARCH => "/-min\.js/",
                            YUI_REPLACE => "-debug.js"
                        )
               );

            foreach ($this->modules as $name=>$m) {

                if (isset($m[YUI_GLOBAL])) {
                    $this->globalModules[$name] = true;
                }

                if (isset($m[YUI_SUPERSEDES])) {
                    $this->rollupModules[$name] = $m;
                    foreach ($m[YUI_SUPERSEDES] as $sup) {
                        $this->mapSatisfyingModule($sup, $name);
                    }
                }
            }
        }
    }
    
    function updateCache() {
        if ($this->fullCacheKey) {
            $cache = array();
            $cache[YUI_MODULES] = $this->modules;
            $cache[YUI_SKIN] = $this->skin;
            $cache[YUI_ROLLUP] = $this->rollupModules;
            $cache[YUI_GLOBAL] = $this->globalModules;
            $cache[YUI_DEPCACHE] = $this->depCache;
            $cache[YUI_SATISFIES] = $this->satisfactionMap;
            $cache[YUI_FILTERS] = $this->filters;
            apc_store($this->fullCacheKey, $cache, $this->apcttl);
        }
    }

    function load() {
        //Expects N-number of named components to load 
        $args = func_get_args();
        foreach ($args as $arg) {
            $this->loadSingle($arg);
        }
    }
    
    function setProcessedModuleType($moduleType='ALL') {
        $this->processedModuleTypes[$moduleType] = true;
    }
    
    function hasProcessedModuleType($moduleType='ALL') {
        return isset($this->processedModuleTypes[$moduleType]);
    }

    function setLoaded() {
        $args = func_get_args();

        foreach ($args as $arg) {
            if (isset($this->modules[$arg])) {
                $this->loaded[$arg] = $arg;
                $mod = $this->modules[$arg];

                $sups = $this->getSuperceded($arg);
                // accounting for by way of supersede
                foreach ($sups as $supname=>$val) {
                    $this->loaded[$supname] = $supname;
                }

                // prevent rollups for this module type
                $this->setProcessedModuleType($mod[YUI_TYPE]);
            } else {
                $msg = "YUI_LOADER: undefined module name provided to setLoaded(): " . $arg;
                error_log($msg, 0);
            }
        }
    }
    
    function skinSetup($name) {
        $skinName = null;
        $dep = $this->modules[$name];

        if ($dep && isset($dep[YUI_SKINNABLE])) {
            $s = $this->skin;
            
            if (isset($s[YUI_OVERRIDES][$name])) {
                foreach ($s[YUI_OVERRIDES][$name] as $name2 => $over2) {
                    $skinName = $this->formatSkin($over2, $name);
                }
            } else {
                $skinName = $this->formatSkin($s["defaultSkin"], $name);
            }

            // adding new skin module
            $this->skins[] = $skinName;
            $skin = $this->parseSkin($skinName);

            // module-specific
            if (isset($skin[2])) {
                $dep = $this->modules[$skin[2]];
                $package = (isset($dep[YUI_PKG])) ? $dep[YUI_PKG] : $skin[2];
                $path = $package . '/' . $s[YUI_BASE] . $skin[1] . '/' . $skin[2] . '.css';
                $this->modules[$skinName] = array(
                        "name" => $skinName,
                        "type" => YUI_CSS,
                        "path" => $path,
                        "after" => $s[YUI_AFTER]
                    );

            // rollup skin
            } else {
                $path = $s[YUI_BASE] . $skin[1] . '/' . $s[YUI_PATH];
                $newmod = array(
                        "name" => $skinName,
                        "type" => YUI_CSS,
                        "path" => $path,
                        "rollup" => 3,
                        "after" => $s[YUI_AFTER]
                    );
                $this->modules[$skinName] = $newmod;
                $this->rollupModules[$skinName] = $newmod;
            }

        }    

        return $skinName;
    }
    
    function parseSkin($moduleName) {
        if (strpos( $moduleName, $this->skin[YUI_PREFIX] ) === 0) {
            return explode('-', $moduleName);
        }

        return null;
    }
    
    function formatSkin($skin, $moduleName) {
        $prefix = $this->skin[YUI_PREFIX];
        $s = $prefix . $skin;
        if ($moduleName) {
            $s = $s . '-' . $moduleName;
        }

        return $s;
    }
    
    function loadSingle($name) {
        $skin = $this->parseSkin($name);

        if ($skin) {
            $this->skins[] = $name;
            $this->dirty = true;
            return true;
        }

        if (!isset($this->modules[$name])) {
            $this -> undefined[$name] = $name;
            return false;
        }

        if (isset($this->loaded[$name]) || isset($this->accountedFor[$name])) {
            // skip
        } else {
            $this->requests[$name] = $name;
            $this->dirty = true;
        }
        
        return true;
    }

    function script() {
        return $this->tags(YUI_JS);
    }
    
    function css() {
        return $this->tags(YUI_CSS);
    }

    function tags($moduleType=null, $skipSort=false) {
        return $this->processDependencies(YUI_TAGS, $moduleType, $skipSort);
    }
    
    function script_embed() {
        return $this->embed(YUI_JS);
    }
    
    function css_embed() {
        return $this->embed(YUI_CSS);
    }

    function embed($moduleType=null, $skipSort=false) {
        return $this->processDependencies(YUI_EMBED, $moduleType, $skipSort);
    }

    function script_data() {
        return $this->data(YUI_JS);
    }

    function css_data() {
        return $this->data(YUI_CSS);
    }
    
    function data($moduleType=null, $allowRollups=false, $skipSort=false) {
        if (!$allowRollups) {
            $this->setProcessedModuleType($moduleType);
        }

        $type = YUI_DATA;

        return $this->processDependencies($type, $moduleType, $skipSort);
    }

    function script_json() {
        return $this->json(YUI_JS);
    }
    
    function css_json() {
        return $this->json(YUI_CSS);
    }

    function json($moduleType=null, $allowRollups=false, $skipSort=false, $full=false) {
        if (!$allowRollups) {
            $this->setProcessedModuleType($moduleType);
        }

        // the original JSON output only sent the provides data, not the requires
        $type = YUI_JSON;

        if ($full) {
            $type = YUI_FULLJSON;
        }

        return $this->processDependencies($type, $moduleType, $skipSort);
    }
 
    function script_raw() {
        return $this->raw(YUI_JS);
    }

    function css_raw() {
        return $this->raw(YUI_CSS);
    }

    function raw($moduleType=null, $allowRollups=false, $skipSort=false) {
        return $this->processDependencies(YUI_RAW, $moduleType, $skipSort);
    }
    
    function log($msg) {
        error_log($msg, 0);
    }
    
    function accountFor($name) {
        $this->accountedFor[$name] = $name;
        
        if (isset($this->modules[$name])) {
            $dep = $this->modules[$name];
            $sups = $this->getSuperceded($name);
            foreach ($sups as $supname=>$val) {
                // accounting for by way of supersede package
                $this->accountedFor[$supname] = true;
            }
        }
    }

    function prune($deps, $moduleType) {
        if ($moduleType) {
            $newdeps = array();
            foreach ($deps as $name=>$val) {
                $dep = $this->modules[$name];
                if ($dep[YUI_TYPE] == $moduleType) {
                    $newdeps[$name] = true;
                }
            }
            return $newdeps;
        } else {
            return $deps;
        }
   }
   
   function getSuperceded($name) {
        $key = YUI_SUPERSEDES . $name;

        if (isset($this->depCache[$key])) {
            return $this->depCache[$key];
        }

        $sups = array();

        if (isset($this->modules[$name])) {
            $m = $this->modules[$name];
            if (isset($m[YUI_SUPERSEDES])) {
                foreach ($m[YUI_SUPERSEDES] as $supName) {
                    $sups[$supName] = true;
                    if (isset($this->modules[$supName])) {
                        $supsups = $this->getSuperceded($supName);
                        if (count($supsups) > 0) {
                            $sups = array_merge($sups, $supsups);
                        }
                    } 
                }
            }
        }

        $this->depCache[$key] = $sups;
        return $sups;
    }
    
    function getAllDependencies($mname, $loadOptional=false, $completed=array()) {
        $key = YUI_REQUIRES . $mname;
        if ($loadOptional) {
            $key .= YUI_OPTIONAL;
        }
        
        if (isset($this->depCache[$key])) {
            return $this->depCache[$key];
        }
        
        $m = $this->modules[$mname];
        $mProvides = $this->getProvides($mname);
        $reqs = array();
    
            //Some modules pretend to be others (override if this is the case)
        if (isset($this->modules[$mname][YUI_EXPOUND])) {
                        if (!isset($completed[$mname])) {
                                $reqs = array_merge($completed, $this->getAllDependencies($this->modules[$mname][YUI_EXPOUND], $loadOptional, array($mname => true)));
                        }
        }

        //Add any requirements defined on the module itself
        if (isset($m[YUI_REQUIRES])) {
            $origreqs = $m[YUI_REQUIRES];
            foreach($origreqs as $r) {
                if (!isset($reqs[$r])) {
                        $reqs[$r] = true;
                        $reqs = array_merge($reqs, $this->getAllDependencies($r, $loadOptional, $reqs));
                }
            }
        }
         
        //Add any submodule requirements not provided by the rollups
        if (isset($m[YUI_SUBMODULES])) {
            foreach($m[YUI_SUBMODULES] as $submodule) {
                $subreqs = $submodule[YUI_REQUIRES];
                foreach($subreqs as $sr) {     
                    if (!in_array($sr, $mProvides) && !in_array($sr, $this->accountedFor)) {
                                if (!isset($reqs[$sr])) {
                                $reqs[$sr] = true; 
                                $reqs = array_merge($reqs, $this->getAllDependencies($sr, $loadOptional, $reqs));
                                }
                    }
                }
            }
        }
        
        //Add any superseded requirements not provided by the rollup and/or rollup submodules
        if (isset($m[YUI_SUPERSEDES])) {
            foreach($m[YUI_SUPERSEDES] as $supersededModule) {
                if (isset($this->modules[$supersededModule][YUI_REQUIRES])) {
                    foreach($this->modules[$supersededModule][YUI_REQUIRES] as $supersededModuleReq) {
                        if (!in_array($supersededModuleReq, $mProvides)) {
                                        if (!isset($reqs[$supersededModuleReq])) {
                                    $reqs[$supersededModuleReq] = true;
                                    $reqs = array_merge($reqs, $this->getAllDependencies($supersededModuleReq, $loadOptional, $reqs));
                                        }
                        }
                    }
                }
                
                //Add any submodule requirements not provided by the rollup or originally requested module
                if (isset($this->modules[$supersededModule][YUI_SUBMODULES])) {
                    foreach($this->modules[$supersededModule][YUI_SUBMODULES] as $supersededSubmodule) {
                        $ssmProvides = $this->getProvides($supersededModule);
                        $supersededSubreqs = $supersededSubmodule[YUI_REQUIRES];
                        foreach($supersededSubreqs as $ssr) {     
                            if (!in_array($ssr, $ssmProvides)) {
                                                if (!isset($reqs[$ssr])) {
                                        $reqs[$ssr] = true;
                                        $reqs = array_merge($reqs, $this->getAllDependencies($ssr, $loadOptional, $reqs));
                                                }
                            }
                        }
                    }
                }
            }
        }

        if ($loadOptional && isset($m[YUI_OPTIONAL])) {
            $o = $m[YUI_OPTIONAL];
            foreach($o as $opt) {
                $reqs[$opt] = true;
            }
        }

        $this->depCache[$key] = $reqs;
        
        return $reqs;
    }

    // @todo restore global dependency support
    function getGlobalDependencies() {
        return $this->globalModules;
    }

    function moduleSatisfies($satisfied, $satisfier) {
        if($satisfied == $satisfier) {
            return true;
        }

        if (isset($this->satisfactionMap[$satisfied])) {
            $satisfiers = $this->satisfactionMap[$satisfied];
            return isset($satisfiers[$satisfier]);
        }

        return false;
    }

    function overrideBase($base, $modules) {
        foreach ($modules as $name) {
            $this->baseOverrides[$name] = $base;
        }
    }
    
    function listSatisfies($satisfied, $moduleList) {
        if (isset($moduleList[$satisfied])) {
            return true;
        } else {
            if (isset($this->satisfactionMap[$satisfied])) {
                $satisfiers = $this->satisfactionMap[$satisfied];
                foreach ($satisfiers as $name=>$val) {
                    if (isset($moduleList[$name])) {
                        return true;
                    }
                }
            }
        }

        return false;
    }
    
    function checkThreshold($module, $moduleList) {
        if (count($moduleList) > 0 && isset($module[YUI_ROLLUP])) {
            $matched = 0;
            $thresh = $module[YUI_ROLLUP];
            foreach ($moduleList as $moduleName=>$moddef) {
                if (in_array($moduleName, $module[YUI_SUPERSEDES])) {
                    $matched++;
                }
            }
            
            return ($matched >= $thresh);
        }

        return false;
    }
    
    function sortDependencies($moduleType, $skipSort=false) {
        $reqs = array();
        $top = array();
        $bot = array();
        $notdone = array();
        $sorted = array();
        $found = array();

        // add global dependenices so they are included when calculating rollups
        $globals = $this->getGlobalDependencies($moduleType);
        
        foreach ($globals as $name=>$dep) {
            $reqs[$name] = true;
        }
        
        // get and store the full list of dependencies.
        foreach ($this->requests as $name=>$val) {
            $reqs[$name] = true;
            $dep = $this->modules[$name];
            $newreqs = $this->getAllDependencies($name, $this->loadOptional);
            
            foreach ($newreqs as $newname=>$newval) {
                if (!isset($reqs[$newname])) {
                    $reqs[$newname] = true;
                }
            }
        }

        // if we skip the sort, we just return the list that includes everything that
        // was requested, all of their requirements, and global modules.  This is
        // filtered by module type if supplied
        if ($skipSort) {
            return $this->prune($reqs, $moduleType);
        }

        // if we are sorting again after new modules have been requested, we
        // do not rollup, and we can remove the accounted for modules
        if (count($this->accountedFor) > 0 || count($this->loaded) > 0) {
            foreach ($this->accountedFor as $name=>$val) {
                if (isset($reqs[$name])) {
                    unset($reqs[$name]);
                }
            }
            
            // removing satisfied req (loaded)
            foreach ($this->loaded as $name=>$val) {
                if (isset($reqs[$name])) {
                    unset($reqs[$name]);
                }
            }
        } else if ($this->allowRollups) {
            // First we go through the meta-modules we know about to 
            // see if the replacement threshold has been met.
            $rollups = $this->rollupModules;

            if (count($rollups > 0)) {
                foreach ($rollups as $name => $rollup) {
                    if (!isset($reqs[$name]) && $this->checkThreshold($rollup, $reqs) ) {
                        $reqs[$name] = true;
                        $dep = $this->modules[$name];
                        $newreqs = $this->getAllDependencies($name, $this->loadOptional, $reqs);
                        foreach ($newreqs as $newname=>$newval) {
                            if (!isset($reqs[$newname])) {
                                $reqs[$newname] = true;
                            }
                        }
                    }
                }
            }
        }

        // clear out superceded packages
        foreach ($reqs as $name => $val) {
            $dep = $this->modules[$name];

            if (isset($dep[YUI_SUPERSEDES])) {
                $override = $dep[YUI_SUPERSEDES];
                
                foreach ($override as $i=>$val) {
                    if (isset($reqs[$val])) {
                        unset($reqs[$val]);
                    }

                    if (isset($reqs[$i])) {
                        unset($reqs[$i]);
                    }
                }
            }
        }

        // move globals to the top
        foreach ($reqs as $name => $val) {
            $dep = $this->modules[$name];
            if (isset($dep[YUI_GLOBAL]) && $dep[YUI_GLOBAL]) {
                $top[$name] = $name;
            } else {
                $notdone[$name] = $name;
            }
        }

        // merge new order if we have globals   
        if (count($top > 0)) {
            $notdone = array_merge($top, $notdone);
        }

        // keep track of what is accounted for
        foreach ($this->loaded as $name=>$module) {
            $this->accountFor($name);
        }

        // keep going until everything is sorted
        $count = 0;
        while (count($notdone) > 0) {
            if ($count++ > 200) {
                $msg = "YUI_LOADER ERROR: sorting could not be completed, there may be a circular dependency";
                error_log($msg, 0);
                return array_merge($sorted, $notdone);
            }
            
            // each pass only processed what has not been completed
            foreach ($notdone as $name => $val) {
                $dep = $this->modules[$name];                
                $newreqs = $this->getAllDependencies($name, $this->loadOptional);
                $this->accountFor($name);    
                
                //Detect if this module needs to be included after another one of the upcoming dependencies
                if (isset($dep[YUI_AFTER])) {
                    $after = $dep[YUI_AFTER];
                    
                    foreach($after as $a) {
                        if (in_array($a, $notdone)) {
                            $newreqs[$a] = true;
                        }
                    }
                }

                if (!empty($newreqs)) {
                    foreach ($newreqs as $depname=>$depval) {
                        // check if the item is accounted for in the $done list
                        if (isset($this->accountedFor[$depname]) || $this->listSatisfies($depname, $sorted)) {
                                //unset($notdone[$depname]);
                        } else {
                            $tmp = array();
                            $found = false;
                            foreach ($notdone as $newname => $newval) {
                                if ($this->moduleSatisfies($depname, $newname)) {
                                    $tmp[$newname] = $newname;
                                    unset($notdone[$newname]);
                                    $found = true;
                                    break; // found something that takes care of the dependency, so jump out
                                }
                            }
                            
                            if ($found) {
                                // this should put the module that handles the dependency on top, immediately
                                // over the the item with the missing dependency
                                $notdone = array_merge($tmp, $notdone);
                            } else {
                                //Requirement was missing and not found within the current notdone list.  Add and try again.
                                $notdone[$depname] = $depname;
                            }
                            
                            break(2); // break out of this iteration so we can get the missed dependency
                        }
                    }
                }
            
                $sorted[$name] = $name;
                unset($notdone[$name]);
            }
        }
        
        //Deal with module skins
        foreach ($sorted as $name => $val) {
            $skinName = $this->skinSetup($name);
        }

        if ( count($this->skins) > 0 ) {
            foreach ($this->skins as $name => $val) {
                $sorted[$val] = true;
            }
        }

        $this->dirty = false;
        $this->sorted = $sorted;

        // store the results, set clear the diry flag
        return $this->prune($sorted, $moduleType);
    }
 
    function mapSatisfyingModule($satisfied, $satisfier) {
        if (!isset($this->satisfactionMap[$satisfied])) {
            $this->satisfactionMap[$satisfied] = array();
        }

        $this->satisfactionMap[$satisfied][$satisfier] = true;
    }
    
    function processDependencies($outputType, $moduleType, $skipSort=false, $showLoaded=false) {
        $html = '';

        // sort the output with css on top unless the output type is json
        if ((!$moduleType) && (strpos($outputType, YUI_JSON) === false) && $outputType != YUI_DATA) {
            $this->delayCache = true;
            $css = $this->processDependencies($outputType, YUI_CSS, $skipSort, $showLoaded);
            $js  = $this->processDependencies($outputType, YUI_JS, $skipSort, $showLoaded);

            // If the data has not been cached, cache what we have
            if (!$this->cacheFound) {
                $this->updateCache();
            }

            return $css . $js;
        }
        
        $json = array();

        if ($showLoaded || (!$this->dirty && count($this->sorted) > 0)) {
            $sorted = $this->prune($this->sorted, $moduleType);
        } else {
            $sorted = $this->sortDependencies($moduleType, $skipSort);
        }

        foreach ($sorted as $name => $val) {
            if ($showLoaded || !isset($this->loaded[$name])) {
                $dep = $this->modules[$name];
                // only generate the tag once
                switch ($outputType) {
                    case YUI_EMBED:
                        $html .= $this->getContent($name, $dep[YUI_TYPE])."\n";
                        break;
                    case YUI_RAW:
                        $html .= $this->getRaw($name)."\n";
                        break;
                    case YUI_JSON:
                    case YUI_DATA:
                        //$json[$dep[YUI_TYPE]][$this->getUrl($name)] = $this->getProvides($name);
                        $json[$dep[YUI_TYPE]][] = array(
                                $this->getUrl($name) => $this->getProvides($name)
                            );
                        break;
                    case YUI_FULLJSON:
                        $json[$dep[YUI_NAME]] = array();
                        $item = $json[$dep[YUI_NAME]];
                        $item[YUI_TYPE] = $dep[YUI_TYPE];
                        $item[YUI_URL] = $this->getUrl($name);
                        $item[YUI_PROVIDES] = $this->getProvides($name);
                        $item[YUI_REQUIRES] = $dep[YUI_REQUIRES];
                        $item[YUI_OPTIONAL] = $dep[YUI_OPTIONAL];
                        break;
                    case YUI_TAGS:
                    default:
                        if ($this->combine === true && $this->customModulesInUse === false) {
                            $this->addToCombo($name, $dep[YUI_TYPE]);
                            $html = $this->getComboLink($dep[YUI_TYPE]);
                        } else {
                           $html .= $this->getLink($name, $dep[YUI_TYPE])."\n";
                        }
                }
            }
        }

        // If the data has not been cached, and we are not running two
        // rotations for separating css and js, cache what we have
        if (!$this->cacheFound && !$this->delayCache) {
            $this->updateCache();
        }

        if (!empty($json)) {
            if ($this->canJSON()) {
                $html .= json_encode($json);
            } else {
                $html .= "<!-- JSON not available, request failed -->";
            }
        }

        // after the first pass we no longer try to use meta modules
        $this->setProcessedModuleType($moduleType);

        // keep track of all the stuff we loaded so that we don't reload 
        // scripts if the page makes multiple calls to tags
        $this->loaded = array_merge($this->loaded, $sorted);
        if ($this->combine === true) {
            $this->clearComboLink($outputType);
        }

        // return the raw data structure
        if ($outputType == YUI_DATA) {
            return $json;
        }

        if ( count($this->undefined) > 0 ) {
            $html .= "<!-- The following modules were requested but are not defined: " . join($this -> undefined, ",") . " -->\n";
        }

        return $html;
    }

    function getUrl($name) {
        // figure out how to set targets and filters
        $url = "";
        $b = $this->base;
        if (isset($this->baseOverrides[$name])) {
            $b = $this->baseOverrides[$name];
        }

        if (isset($this->modules[$name])) {
            $m = $this->modules[$name];
            if (isset($m[YUI_FULLPATH])) {
                $url = $m[YUI_FULLPATH];
            } else {
                $url = $b . $m[YUI_PATH];
            }
        } else {
            $url = $b . $name;
        }

        if ($this->filter) {
            if (count($this->filterList) > 0 && !isset($this->filterList[$name])) {
                // skip the filter
            } else if (isset($this->filters[$this->filter])) {
                $filter = $this->filters[$this->filter];
                $url = preg_replace($filter[YUI_SEARCH], $filter[YUI_REPLACE], $url);
            }
        }

        if ($this->version) {
            $pre = (strstr($url, '?')) ? '&' : '?';
            $url .= $pre . $this->versionKey . '=' . $this->version;
        }
        
        return $url;
    }

    function getRemoteContent($url) {
        $remote_content = null;
        if ($this->apcAvail === true) {
            $remote_content = apc_fetch($url);
        }        

        if (!$remote_content) {
            if($this->curlAvail === true) {
                $ch = curl_init();
                curl_setopt($ch, CURLOPT_URL, $url);
                curl_setopt($ch, CURLOPT_FAILONERROR, 1); 

                //Doesn't work in safe mode or with openbase_dir enabled, see http://au.php.net/manual/ro/function.curl-setopt.php#71313.
                $open_basedir = ini_get("open_basedir");
                if (empty($open_basedir) && !ini_get('safe_mode')) {
                    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);// allow redirects
                }

                curl_setopt($ch, CURLOPT_RETURNTRANSFER,1); // return into a variable 
                // curl_setopt($ch, CURLOPT_TIMEOUT, 3); // times out after 4s

                $remote_content = curl_exec($ch);

                // save the contents of the remote url for 30 minutes
                if ($this->apcAvail === true) {
                    apc_store($url, $remote_content, $this->apcttl);
                }

                curl_close ($ch);
            } else {
                $remote_content = "<!--// cURL was not detected, so the content cannot be fetched -->";
            }   
        }

        return $remote_content;
    }
    
    function getRaw($name) {        
        if(!$this->curlAvail) {
            return "<!--// cURL was not detected, so the content cannot be fetched -->";
        }

        $url = $this->getUrl($name);
        return $this->getRemoteContent($url);
    }

    function getContent($name, $type) {
        if(!$this->curlAvail) {
            return "<!--// cURL was not detected, so the content cannot be fetched/embedded -->" . $this->getLink($name, $type);
        }

        $url = $this->getUrl($name);

        if (!$url) {
            return '<!-- PATH FOR "'. $name . '" NOT SPECIFIED -->';
        } else if ($type == YUI_CSS) {
            return '<style type="text/css">' . $this->getRemoteContent($url) . '</style>';
        } else {
            return '<script type="text/javascript">' . $this->getRemoteContent($url) . '</script>'; 
        }
    }
    
    function getLink($name, $type) {
        $url = $this->getUrl($name);

        if (!$url) {
            return '<!-- PATH FOR "'. $name . '" NOT SPECIFIED -->';
        } else if ($type == YUI_CSS) {
            return '<link rel="stylesheet" type="text/css" href="' . $url . '" />';
        } else {
            return '<script type="text/javascript" src="' . $url . '"></script>';
        }
    }
  
    function getComboLink($type) {
        $url = '';
        
        if ($type == YUI_CSS) {
            if ($this->cssComboLocation !== null) {
                $url = "<link rel=\"stylesheet\" type=\"text/css\" href=\"{$this->cssComboLocation}\" />";
            } else {
                $url = "<!-- NO YUI CSS COMPONENTS IDENTIFIED -->";
            }
        } else if ($type == YUI_JS) {
            if ($this->jsComboLocation !== null) {
                if ($this->cssComboLocation !== null) {
                    $url = "\n";
                }
                $url .= "<script type=\"text/javascript\" src=\"{$this->jsComboLocation}\"></script>";
            } else {
                $url = "<!-- NO YUI JAVASCRIPT COMPONENTS IDENTIFIED -->";
            }
        }
        
        //Allow for RAW & DEBUG over minified default
        if ($this->filter) {
            if (count($this->filterList) > 0 && !isset($this->filterList[$name])) {
                // skip the filter
            } else if (isset($this->filters[$this->filter])) {
                $filter = $this->filters[$this->filter];
                $url = preg_replace($filter[YUI_SEARCH], $filter[YUI_REPLACE], $url);
            }
        }
        
        return $url;
    }
    
    function clearComboLink($type) {
        if ($type == YUI_CSS) {
            $this->cssComboLocation = null;
        } else if ($type == YUI_JS) {
            $this->jsComboLocation = null;
        } else {
            $this->cssComboLocation = null;
            $this->jsComboLocation  = null;
        }
    }
    
    function addToCombo($name, $type) {
        $pathToModule = $this->comboDefaultVersion . '/build/' . $this->modules[$name][YUI_PATH];
        if ($type == YUI_CSS) {
            //If this is the first css component then add the combo base path
            if ($this->cssComboLocation === null) {
                $this->cssComboLocation = $this->comboBase . $pathToModule;
            } else {
                //Prep for next component
                $this->cssComboLocation .= '&' . $pathToModule;
            }
        } else {
            //If this is the first js component then add the combo base path
            if ($this->jsComboLocation === null) {
                $this->jsComboLocation = $this->comboBase . $pathToModule;
            } else {
                //Prep for next component
                $this->jsComboLocation .= '&' . $pathToModule;
            }
        }
    }
  
    function canJSON() {
        return $this->jsonAvail;
    }
    
    function getProvides($name) {
        $p = array($name);
        if (isset($this->modules[$name])) {
            $m = $this->modules[$name];
            if (isset($m[YUI_SUPERSEDES])) {
                foreach ($m[YUI_SUPERSEDES] as $i) {
                    $p[] = $i;
                }
            }
        }

        return $p;
    }
    
    function getLoadedModules() {
        $loaded = array();
        foreach ($this->loaded as $i=>$value) {
            if (isset($this->modules[$i])) {
                $dep = $this->modules[$i];
                $loaded[$dep[YUI_TYPE]][] = array(
                        $this->getUrl($i) => $this->getProvides($i)
                    );
            } else {
                $msg = "YUI_LOADER ERROR: encountered undefined module: " . $i;
                error_log($msg, 0);
            }
        }
        return $loaded;
    }

    function getLoadedModulesAsJSON() {
        if (!$this->canJSON()) {
            return "{\"Error\", \"json library not available\"}";
        }

        return json_encode($this->getLoadedModules());
    }
}

?>