WebSVN – Applications.gtt – Diff – /trunk/bibliotheque/pear/PEAR/Config.php

 /**
  * PEAR_Config, customized configuration handling for the PEAR Installer
+ *
  * PHP versions 4 and 5
+ *
- * LICENSE: This source file is subject to version 3.0 of the PHP license
- * that is available through the world-wide-web at the following URI:
- * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
- * the PHP License and are unable to obtain it through the web, please
- * send a note to license@php.net so we can mail you a copy immediately.
- *
  * @category   pear
  * @package    PEAR
  * @author     Stig Bakken <ssb@php.net>
  * @author     Greg Beaver <cellog@php.net>
- * @copyright  1997-2006 The PHP Group
+ * @copyright  1997-2009 The Authors
- * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
+ * @license    http://opensource.org/licenses/bsd-license.php New BSD License
- * @version    CVS: $Id: Config.php,v 1.137 2006/11/19 21:33:00 cellog Exp $
  * @link       http://pear.php.net/package/PEAR
  * @since      File available since Release 0.1
  */
  */
 require_once 'PEAR.php';
 require_once 'PEAR/Registry.php';
 require_once 'PEAR/Installer/Role.php';
 require_once 'System.php';
-require_once 'PEAR/Remote.php';
 /**
  * Last created PEAR_Config instance.
  * @var object
 // PHP_ prefix is for some security, PHP protects environment
 // variables starting with PHP_*.
 // default channel and preferred mirror is based on whether we are invoked through
+// the "pear" or the "pecl" command
+if (!defined('PEAR_RUNTYPE')) {
+    define('PEAR_RUNTYPE', 'pear');
-// the "pear" or the "pecl" command
+}
-if (!defined('PEAR_RUNTYPE') || PEAR_RUNTYPE == 'pear') {
+if (PEAR_RUNTYPE == 'pear') {
     define('PEAR_CONFIG_DEFAULT_CHANNEL', 'pear.php.net');
 } else {
 // Default for php_dir
 if (getenv('PHP_PEAR_INSTALL_DIR')) {
     define('PEAR_CONFIG_DEFAULT_PHP_DIR', getenv('PHP_PEAR_INSTALL_DIR'));
 } else {
-    if (file_exists($PEAR_INSTALL_DIR) && is_dir($PEAR_INSTALL_DIR)) {
+    if (@file_exists($PEAR_INSTALL_DIR) && is_dir($PEAR_INSTALL_DIR)) {
-        define('PEAR_CONFIG_DEFAULT_PHP_DIR',
-               $PEAR_INSTALL_DIR);
+        define('PEAR_CONFIG_DEFAULT_PHP_DIR', $PEAR_INSTALL_DIR);
     } else {
         define('PEAR_CONFIG_DEFAULT_PHP_DIR', $PEAR_INSTALL_DIR);
+    }
+}
+// Default for metadata_dir
+if (getenv('PHP_PEAR_METADATA_DIR')) {
+    define('PEAR_CONFIG_DEFAULT_METADATA_DIR', getenv('PHP_PEAR_METADATA_DIR'));
+} else {
+    define('PEAR_CONFIG_DEFAULT_METADATA_DIR', '');
+}
 // Default for ext_dir
 if (getenv('PHP_PEAR_EXTENSION_DIR')) {
     define('PEAR_CONFIG_DEFAULT_EXT_DIR', getenv('PHP_PEAR_EXTENSION_DIR'));
 } else {
     define('PEAR_CONFIG_DEFAULT_DATA_DIR',
            $PEAR_INSTALL_DIR.DIRECTORY_SEPARATOR.'data');
+}
+// Default for cfg_dir
+if (getenv('PHP_PEAR_CFG_DIR')) {
+    define('PEAR_CONFIG_DEFAULT_CFG_DIR', getenv('PHP_PEAR_CFG_DIR'));
+} else {
+    define('PEAR_CONFIG_DEFAULT_CFG_DIR',
+           $PEAR_INSTALL_DIR.DIRECTORY_SEPARATOR.'cfg');
+}
+// Default for www_dir
+if (getenv('PHP_PEAR_WWW_DIR')) {
+    define('PEAR_CONFIG_DEFAULT_WWW_DIR', getenv('PHP_PEAR_WWW_DIR'));
+} else {
+    define('PEAR_CONFIG_DEFAULT_WWW_DIR',
+           $PEAR_INSTALL_DIR.DIRECTORY_SEPARATOR.'www');
+}
+// Default for man_dir
+if (getenv('PHP_PEAR_MAN_DIR')) {
+    define('PEAR_CONFIG_DEFAULT_MAN_DIR', getenv('PHP_PEAR_MAN_DIR'));
+} else {
+    if (defined('PHP_MANDIR')) { // Added in PHP5.3.7
+        define('PEAR_CONFIG_DEFAULT_MAN_DIR', PHP_MANDIR);
+    } else {
+        define('PEAR_CONFIG_DEFAULT_MAN_DIR', PHP_PREFIX . DIRECTORY_SEPARATOR .
+           'local' . DIRECTORY_SEPARATOR .'man');
+    }
+}
 // Default for test_dir
 if (getenv('PHP_PEAR_TEST_DIR')) {
     define('PEAR_CONFIG_DEFAULT_TEST_DIR', getenv('PHP_PEAR_TEST_DIR'));
 } else {
  * which are system-defined, user-defined or defaulted.
  * @category   pear
  * @package    PEAR
  * @author     Stig Bakken <ssb@php.net>
  * @author     Greg Beaver <cellog@php.net>
- * @copyright  1997-2006 The PHP Group
+ * @copyright  1997-2009 The Authors
- * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
+ * @license    http://opensource.org/licenses/bsd-license.php New BSD License
- * @version    Release: 1.5.1
+ * @version    Release: 1.10.1
  * @link       http://pear.php.net/package/PEAR
  * @since      Class available since Release 0.1
  */
 class PEAR_Config extends PEAR
+{
-    // {{{ properties
     /**
      * Array of config files used.
+     *
      * @var array layer => config file
      */
         'system' => '',
         'user' => '',
         );
     var $layers = array();
     /**
      * Configuration data, two-dimensional array where the first
      * dimension is the config layer ('user', 'system' and 'default'),
      * and the second dimension is keyname => value.
     var $configuration = array(
         'user' => array(),
         'system' => array(),
         'default' => array(),
         );
     /**
      * Configuration values that can be set for a channel
+     *
      * All other configuration values can only have a global value
      * @var array
      * @access private
      */
     var $_channelConfigInfo = array(
-        'php_dir', 'ext_dir', 'doc_dir', 'bin_dir', 'data_dir',
+        'php_dir', 'ext_dir', 'doc_dir', 'bin_dir', 'data_dir', 'cfg_dir',
-        'test_dir', 'php_bin', 'username', 'password', 'verbose',
+        'test_dir', 'www_dir', 'php_bin', 'php_prefix', 'php_suffix', 'username',
-        'preferred_state', 'umask', 'preferred_mirror',
+        'password', 'verbose', 'preferred_state', 'umask', 'preferred_mirror', 'php_ini'
         );
     /**
      * Channels that can be accessed
             'default' => PEAR_CONFIG_DEFAULT_DATA_DIR,
             'doc' => 'directory where data files are installed',
             'prompt' => 'PEAR data directory',
             'group' => 'File Locations (Advanced)',
             ),
+        'cfg_dir' => array(
+            'type' => 'directory',
+            'default' => PEAR_CONFIG_DEFAULT_CFG_DIR,
+            'doc' => 'directory where modifiable configuration files are installed',
+            'prompt' => 'PEAR configuration file directory',
+            'group' => 'File Locations (Advanced)',
+            ),
+        'www_dir' => array(
+            'type' => 'directory',
+            'default' => PEAR_CONFIG_DEFAULT_WWW_DIR,
+            'doc' => 'directory where www frontend files (html/js) are installed',
+            'prompt' => 'PEAR www files directory',
+            'group' => 'File Locations (Advanced)',
+            ),
+        'man_dir' => array(
+            'type' => 'directory',
+            'default' => PEAR_CONFIG_DEFAULT_MAN_DIR,
+            'doc' => 'directory where unix manual pages are installed',
+            'prompt' => 'Systems manpage files directory',
+            'group' => 'File Locations (Advanced)',
+            ),
         'test_dir' => array(
             'type' => 'directory',
             'default' => PEAR_CONFIG_DEFAULT_TEST_DIR,
             'doc' => 'directory where regression tests are installed',
             'prompt' => 'PEAR test directory',
             'group' => 'File Locations (Advanced)',
             ),
         'cache_dir' => array(
             'type' => 'directory',
             'default' => PEAR_CONFIG_DEFAULT_CACHE_DIR,
-            'doc' => 'directory which is used for XMLRPC cache',
+            'doc' => 'directory which is used for web service cache',
             'prompt' => 'PEAR Installer cache directory',
             'group' => 'File Locations (Advanced)',
             ),
         'temp_dir' => array(
             'type' => 'directory',
             'prompt' => 'PEAR Installer temp directory',
             'group' => 'File Locations (Advanced)',
             ),
         'download_dir' => array(
             'type' => 'directory',
-            'default' => PEAR_CONFIG_DEFAULT_CACHE_DIR,
+            'default' => PEAR_CONFIG_DEFAULT_DOWNLOAD_DIR,
             'doc' => 'directory which is used for all downloaded files',
             'prompt' => 'PEAR Installer download directory',
             'group' => 'File Locations (Advanced)',
             ),
         'php_bin' => array(
             'default' => PEAR_CONFIG_DEFAULT_PHP_BIN,
             'doc' => 'PHP CLI/CGI binary for executing scripts',
             'prompt' => 'PHP CLI/CGI binary',
             'group' => 'File Locations (Advanced)',
             ),
+        'php_prefix' => array(
+            'type' => 'string',
+            'default' => '',
+            'doc' => '--program-prefix for php_bin\'s ./configure, used for pecl installs',
+            'prompt' => '--program-prefix passed to PHP\'s ./configure',
+            'group' => 'File Locations (Advanced)',
+            ),
+        'php_suffix' => array(
+            'type' => 'string',
+            'default' => '',
+            'doc' => '--program-suffix for php_bin\'s ./configure, used for pecl installs',
+            'prompt' => '--program-suffix passed to PHP\'s ./configure',
+            'group' => 'File Locations (Advanced)',
+            ),
         'php_ini' => array(
             'type' => 'file',
             'default' => '',
             'doc' => 'location of php.ini in which to enable PECL extensions on install',
             'prompt' => 'php.ini location',
             'group' => 'File Locations (Advanced)',
             ),
+        'metadata_dir' => array(
+            'type' => 'directory',
+            'default' => PEAR_CONFIG_DEFAULT_METADATA_DIR,
+            'doc' => 'directory where metadata files are installed (registry, filemap, channels, ...)',
+            'prompt' => 'PEAR metadata directory',
+            'group' => 'File Locations (Advanced)',
+            ),
         // Maintainers
         'username' => array(
             'type' => 'string',
             'default' => '',
             'doc' => '(maintainers) your PEAR account name',
             'group' => 'Maintainers',
             ),
         // __channels is reserved - used for channel-specific configuration
         );
-    // }}}
-    // {{{ PEAR_Config([file], [defaults_file])
     /**
      * Constructor.
+     *
      * @param string file to read user-defined options from
+     *
      * @access public
+     *
      * @see PEAR_Config::singleton
      */
-    function PEAR_Config($user_file = '', $system_file = '', $ftp_file = false,
+    function __construct($user_file = '', $system_file = '', $ftp_file = false,
                          $strict = true)
+    {
-        $this->PEAR();
+        parent::__construct();
         PEAR_Installer_Role::initializeConfig($this);
         $sl = DIRECTORY_SEPARATOR;
         if (empty($user_file)) {
             if (OS_WINDOWS) {
                 $user_file = PEAR_CONFIG_SYSCONFDIR . $sl . 'pear.ini';
             } else {
                 $user_file = getenv('HOME') . $sl . '.pearrc';
+            }
+        }
         if (empty($system_file)) {
+            $system_file = PEAR_CONFIG_SYSCONFDIR . $sl;
             if (OS_WINDOWS) {
-                $system_file = PEAR_CONFIG_SYSCONFDIR . $sl . 'pearsys.ini';
+                $system_file .= 'pearsys.ini';
             } else {
-                $system_file = PEAR_CONFIG_SYSCONFDIR . $sl . 'pear.conf';
+                $system_file .= 'pear.conf';
+            }
+        }
         $this->layers = array_keys($this->configuration);
-        $this->files['user'] = $user_file;
+        $this->files['user']   = $user_file;
         $this->files['system'] = $system_file;
         if ($user_file && file_exists($user_file)) {
             $this->pushErrorHandling(PEAR_ERROR_RETURN);
             $this->readConfigFile($user_file, 'user', $strict);
             $this->popErrorHandling();
             if ($this->_errorsFound > 0) {
                 return;
+            }
         }
-        if ($system_file && file_exists($system_file)) {
+        if ($system_file && @file_exists($system_file)) {
             $this->mergeConfigFile($system_file, false, 'system', $strict);
             if ($this->_errorsFound > 0) {
         foreach ($this->configuration_info as $key => $info) {
             $this->configuration['default'][$key] = $info['default'];
         }
+        $this->_registry['default'] = new PEAR_Registry(
+            $this->configuration['default']['php_dir'], false, false,
-        $this->_registry['default'] = &new PEAR_Registry($this->configuration['default']['php_dir']);
+            $this->configuration['default']['metadata_dir']);
-        $this->_registry['default']->setConfig($this);
+        $this->_registry['default']->setConfig($this, false);
         $this->_regInitialized['default'] = false;
+        //$GLOBALS['_PEAR_Config_instance'] = &$this;
+    }
-        //$GLOBALS['_PEAR_Config_instance'] = &$this;
-    }
+    /**
+     * Return the default locations of user and system configuration files
+     */
+    public static function getDefaultConfigFiles()
+    {
+        $sl = DIRECTORY_SEPARATOR;
+        if (OS_WINDOWS) {
+            return array(
+                'user'   => PEAR_CONFIG_SYSCONFDIR . $sl . 'pear.ini',
+                'system' =>  PEAR_CONFIG_SYSCONFDIR . $sl . 'pearsys.ini'
+            );
+        }
+        return array(
+            'user'   => getenv('HOME') . $sl . '.pearrc',
             'system' => PEAR_CONFIG_SYSCONFDIR . $sl . 'pear.conf'
-    // }}}
+        );
     // {{{ singleton([file], [defaults_file])
      * @param string (optional) file to read user-defined options from
      * @param string (optional) file to read system-wide defaults from
+     *
      * @return object an existing or new PEAR_Config instance
+     *
-     * @access public
-     *
      * @see PEAR_Config::PEAR_Config
      */
-    function &singleton($user_file = '', $system_file = '', $strict = true)
+    public static function &singleton($user_file = '', $system_file = '', $strict = true)
+    {
         if (is_object($GLOBALS['_PEAR_Config_instance'])) {
             return $GLOBALS['_PEAR_Config_instance'];
+        }
-        $t_conf = &new PEAR_Config($user_file, $system_file, false, $strict);
+        $t_conf = new PEAR_Config($user_file, $system_file, false, $strict);
         if ($t_conf->_errorsFound > 0) {
              return $t_conf->lastError;
+        }
         $GLOBALS['_PEAR_Config_instance'] = &$t_conf;
-        return $GLOBALS['_PEAR_Config_instance'];
-    }
-    // }}}
+        return $GLOBALS['_PEAR_Config_instance'];
     // {{{ validConfiguration()
     /**
      * Determine whether any configuration files have been detected, and whether a
     function validConfiguration()
+    {
         if ($this->isDefinedLayer('user') || $this->isDefinedLayer('system')) {
             return true;
+        }
         return false;
+    }
-    // }}}
-    // {{{ readConfigFile([file], [layer])
     /**
      * Reads configuration data from a file.  All existing values in
      * the config layer are discarded and replaced with data from the
      * file.
         if ($file === null) {
             $file = $this->files[$layer];
+        }
-        $data = $this->_readConfigDataFrom($file);
         $data = $this->_readConfigDataFrom($file);
         if (PEAR::isError($data)) {
-            if ($strict) {
-                $this->_errorsFound++;
-                $this->lastError = $data;
-                return $data;
-            } else {
+            if (!$strict) {
                 return true;
+            }
-            }
-        } else {
+            $this->_errorsFound++;
+            $this->lastError = $data;
-            $this->files[$layer] = $file;
+            return $data;
+        }
         $this->files[$layer] = $file;
         $this->_decodeInput($data);
         $this->configuration[$layer] = $data;
         $this->_setupChannels();
+        if (!$this->_noRegistry && ($phpdir = $this->get('php_dir', $layer, 'pear.php.net'))) {
+            $this->_registry[$layer] = new PEAR_Registry(
-        if (!$this->_noRegistry && ($phpdir = $this->get('php_dir', $layer, 'pear.php.net'))) {
+                $phpdir, false, false,
-            $this->_registry[$layer] = &new PEAR_Registry($phpdir);
+                $this->get('metadata_dir', $layer, 'pear.php.net'));
-            $this->_registry[$layer]->setConfig($this);
+            $this->_registry[$layer]->setConfig($this, false);
             $this->_regInitialized[$layer] = false;
         } else {
             unset($this->_registry[$layer]);
+        }
-        return true;
-    }
         return true;
     // }}}
     /**
      * @param string url to the remote config file, like ftp://www.example.com/pear/config.ini
+                }
                 if (PEAR_Common::isIncludeable('PEAR/FTP.php')) {
                     require_once 'PEAR/FTP.php';
+                }
+            }
-            if (class_exists('PEAR_FTP')) {
+            if (!class_exists('PEAR_FTP')) {
-                $this->_ftp = &new PEAR_FTP;
-                $this->_ftp->pushErrorHandling(PEAR_ERROR_RETURN);
+                return PEAR::raiseError('PEAR_RemoteInstaller must be installed to use remote config');
-                $e = $this->_ftp->init($path);
-                if (PEAR::isError($e)) {
-                    $this->_ftp->popErrorHandling();
-                    return $e;
-                }
+            }
-                $tmp = System::mktemp('-d');
+            $this->_ftp = new PEAR_FTP;
-                PEAR_Common::addTempFile($tmp);
-                $e = $this->_ftp->get(basename($path), $tmp . DIRECTORY_SEPARATOR .
+            $this->_ftp->pushErrorHandling(PEAR_ERROR_RETURN);
-                    'pear.ini', false, FTP_BINARY);
+            $e = $this->_ftp->init($path);
-                if (PEAR::isError($e)) {
+            if (PEAR::isError($e)) {
-                    $this->_ftp->popErrorHandling();
-                    return $e;
-                }
-                PEAR_Common::addTempFile($tmp . DIRECTORY_SEPARATOR . 'pear.ini');
-                $this->_ftp->disconnect();
                 $this->_ftp->popErrorHandling();
+                return $e;
+            }
+            $tmp = System::mktemp('-d');
+            PEAR_Common::addTempFile($tmp);
+            $e = $this->_ftp->get(basename($path), $tmp . DIRECTORY_SEPARATOR .
+                'pear.ini', false, FTP_BINARY);
+            if (PEAR::isError($e)) {
+                $this->_ftp->popErrorHandling();
+                return $e;
+            }
+            PEAR_Common::addTempFile($tmp . DIRECTORY_SEPARATOR . 'pear.ini');
+            $this->_ftp->disconnect();
+            $this->_ftp->popErrorHandling();
-                $this->files['ftp'] = $tmp . DIRECTORY_SEPARATOR . 'pear.ini';
+            $this->files['ftp'] = $tmp . DIRECTORY_SEPARATOR . 'pear.ini';
-                $e = $this->readConfigFile(null, 'ftp');
+            $e = $this->readConfigFile(null, 'ftp');
-                if (PEAR::isError($e)) {
+            if (PEAR::isError($e)) {
-                    return $e;
+                return $e;
-                }
+            }
-                $fail = array();
+            $fail = array();
-                foreach ($this->configuration_info as $key => $val) {
+            foreach ($this->configuration_info as $key => $val) {
-                    if (in_array($this->getGroup($key),
+                if (in_array($this->getGroup($key),
-                          array('File Locations', 'File Locations (Advanced)')) &&
+                      array('File Locations', 'File Locations (Advanced)')) &&
-                          $this->getType($key) == 'directory') {
+                      $this->getType($key) == 'directory') {
-                        // any directory configs must be set for this to work
+                    // any directory configs must be set for this to work
-                        if (!isset($this->configuration['ftp'][$key])) {
+                    if (!isset($this->configuration['ftp'][$key])) {
-                            $fail[] = $key;
+                        $fail[] = $key;
-                        }
+                    }
+                }
-                if (count($fail)) {
-                    $fail = '"' . implode('", "', $fail) . '"';
-                    unset($this->files['ftp']);
-                    unset($this->configuration['ftp']);
-                    return PEAR::raiseError('ERROR: Ftp configuration file must set all ' .
-                        'directory configuration variables.  These variables were not set: ' .
-                        $fail);
-                } else {
-                    return true;
-                }
-            } else {
-                return PEAR::raiseError('PEAR_RemoteInstaller must be installed to use remote config');
+            }
+            if (!count($fail)) {
+                return true;
+            }
+            $fail = '"' . implode('", "', $fail) . '"';
+            unset($this->files['ftp']);
+            unset($this->configuration['ftp']);
+            return PEAR::raiseError('ERROR: Ftp configuration file must set all ' .
+                'directory configuration variables.  These variables were not set: ' .
+                $fail);
         } while (false); // poor man's catch
         unset($this->files['ftp']);
         return PEAR::raiseError('no remote host specified');
+    }
-    // {{{ _setupChannels()
     /**
      * Reads the existing configurations and creates the _channels array from it
      */
     function _setupChannels()
+        }
         $this->_channels = array_values(array_flip($set));
         $this->setChannels($this->_channels);
+    }
-    // }}}
-    // {{{ deleteChannel(channel)
     function deleteChannel($channel)
+    {
         $ch = strtolower($channel);
-        foreach ($this->configuration as $layer => $data) {
-            if (isset($data['__channels'])) {
+        foreach ($this->configuration as $layer => $data) {
-                if (isset($data['__channels'][strtolower($channel)])) {
+            if (isset($data['__channels']) && isset($data['__channels'][$ch])) {
-                    unset($this->configuration[$layer]['__channels'][strtolower($channel)]);
                 unset($this->configuration[$layer]['__channels'][$ch]);
+            }
+        }
         $this->_channels = array_flip($this->_channels);
-        unset($this->_channels[strtolower($channel)]);
+        unset($this->_channels[$ch]);
         $this->_channels = array_flip($this->_channels);
-    }
-    // }}}
     // {{{ mergeConfigFile(file, [override], [layer])
     /**
      * Merges data into a config layer from a file.  Does the same
      * thing as readConfigFile, except it does not replace all
     function mergeConfigFile($file, $override = true, $layer = 'user', $strict = true)
+    {
         if (empty($this->files[$layer])) {
             return $this->raiseError("unknown config layer `$layer'");
+        }
         if ($file === null) {
             $file = $this->files[$layer];
+        }
         $data = $this->_readConfigDataFrom($file);
         if (PEAR::isError($data)) {
-            if ($strict) {
+            if (!$strict) {
-                $this->_errorsFound++;
-                $this->lastError = $data;
-                return $data;
-            } else {
                 return true;
+            }
+            $this->_errorsFound++;
+            $this->lastError = $data;
+            return $data;
+        }
         $this->_decodeInput($data);
         if ($override) {
             $this->configuration[$layer] =
                 PEAR_Config::arrayMergeRecursive($this->configuration[$layer], $data);
         } else {
             $this->configuration[$layer] =
                 PEAR_Config::arrayMergeRecursive($data, $this->configuration[$layer]);
+        }
         $this->_setupChannels();
         if (!$this->_noRegistry && ($phpdir = $this->get('php_dir', $layer, 'pear.php.net'))) {
-            $this->_registry[$layer] = &new PEAR_Registry($phpdir);
+            $this->_registry[$layer] = new PEAR_Registry(
+                $phpdir, false, false,
+                $this->get('metadata_dir', $layer, 'pear.php.net'));
-            $this->_registry[$layer]->setConfig($this);
+            $this->_registry[$layer]->setConfig($this, false);
             $this->_regInitialized[$layer] = false;
         } else {
             unset($this->_registry[$layer]);
+        }
         return true;
+    }
-    // }}}
     // {{{ arrayMergeRecursive($arr2, $arr1)
     /**
      * @param array
      * @param array
-     * @return array
-     * @static
+     * @return array
      */
-    function arrayMergeRecursive($arr2, $arr1)
+    public static function arrayMergeRecursive($arr2, $arr1)
+    {
         $ret = array();
         foreach ($arr2 as $key => $data) {
             if (!isset($arr1[$key])) {
+                }
                 $ret[$key] = PEAR_Config::arrayMergeRecursive($arr1[$key], $arr2[$key]);
                 unset($arr1[$key]);
+            }
+        }
         return array_merge($ret, $arr1);
+    }
-    // }}}
-    // {{{ writeConfigFile([file], [layer])
     /**
      * Writes data into a config layer from a file.
+     *
      * @param string|null file to read from, or null for default
                     return $err;
+                }
+            }
             return true;
+        }
         if (empty($this->files[$layer])) {
             return $this->raiseError("unknown config file type `$layer'");
+        }
         if ($file === null) {
             $file = $this->files[$layer];
+        }
         $data = ($data === null) ? $this->configuration[$layer] : $data;
         $this->_encodeOutput($data);
         $opt = array('-p', dirname($file));
         if (!@System::mkDir($opt)) {
             return $this->raiseError("could not create directory: " . dirname($file));
+        }
         if (file_exists($file) && is_file($file) && !is_writeable($file)) {
             return $this->raiseError("no write access to $file!");
+        }
         $fp = @fopen($file, "w");
         if (!$fp) {
             return $this->raiseError("PEAR_Config::writeConfigFile fopen('$file','w') failed ($php_errormsg)");
+        }
         $contents = "#PEAR_Config 0.9\n" . serialize($data);
         if (!@fwrite($fp, $contents)) {
             return $this->raiseError("PEAR_Config::writeConfigFile: fwrite failed ($php_errormsg)");
+        }
         return true;
+    }
-    // }}}
-    // {{{ _readConfigDataFrom(file)
     /**
      * Reads configuration data from a file and returns the parsed data
      * in an array.
+     *
-     * @param string file to read from
      * @param string file to read from
-     * @return array configuration data or a PEAR error on failure
      * @return array configuration data or a PEAR error on failure
      * @access private
      */
     function _readConfigDataFrom($file)
+    {
         $fp = false;
         if (file_exists($file)) {
             $fp = @fopen($file, "r");
+        }
         if (!$fp) {
             return $this->raiseError("PEAR_Config::readConfigFile fopen('$file','r') failed");
+        }
-        $size = filesize($file);
-        $rt = get_magic_quotes_runtime();
-        set_magic_quotes_runtime(0);
+        $size = filesize($file);
         fclose($fp);
         $contents = file_get_contents($file);
         if (empty($contents)) {
             return $this->raiseError('Configuration file "' . $file . '" is empty');
-        }
         set_magic_quotes_runtime($rt);
         $version = false;
         if (preg_match('/^#PEAR_Config\s+(\S+)\s+/si', $contents, $matches)) {
             // Museum config file
             if (substr($contents,0,2) == 'a:') {
                 $version = '0.1';
+            }
+        }
-        if ($version && version_compare("$version", '1', '<')) {
         if ($version && version_compare("$version", '1', '<')) {
             // no '@', it is possible that unserialize
             // raises a notice but it seems to block IO to
             // STDOUT if a '@' is used and a notice is raise
             if (!is_array($data)) {
                 if (strlen(trim($contents)) > 0) {
                     $error = "PEAR_Config: bad data in $file";
                     $err = $this->raiseError($error);
                     return $err;
-                } else {
-                    $data = array();
+                }
+                $data = array();
+            }
         // add parsing of newer formats here...
         } else {
             $err = $this->raiseError("$file: unknown version `$version'");
             return $err;
+        }
         return $data;
+    }
-    // }}}
     // {{{ getConfFile(layer)
     /**
     * Gets the file used for storing the config for a layer
+    *
     * @param string $layer 'user' or 'system'
-    */
     */
     function getConfFile($layer)
+    {
         return $this->files[$layer];
-    }
     // }}}
     /**
-    /**
+     * @param string Configuration class name, used for detecting duplicate calls
      * @param array information on a role as parsed from its xml file
      * @return true|PEAR_Error
      * @access private
      */
+    function _addConfigVars($class, $vars)
+    {
+        static $called = array();
+        if (isset($called[$class])) {
+            return;
+        }
     function _addConfigVars($vars)
         $called[$class] = 1;
         if (count($vars) > 3) {
+            return $this->raiseError('Roles can only define 3 new config variables or less');
             return $this->raiseError('Roles can only define 3 new config variables or less');
         foreach ($vars as $name => $var) {
             if (!is_array($var)) {
+                return $this->raiseError('Configuration information must be an array');
                 return $this->raiseError('Configuration information must be an array');
-            if (!isset($var['type'])) {
-                return $this->raiseError('Configuration information must contain a type');
+            if (!isset($var['type'])) {
-            } else {
+                return $this->raiseError('Configuration information must contain a type');
-                if (!in_array($var['type'],
+            } elseif (!in_array($var['type'],
-                      array('string', 'mask', 'password', 'directory', 'file', 'set'))) {
+                    array('string', 'mask', 'password', 'directory', 'file', 'set'))) {
-                    return $this->raiseError(
+                  return $this->raiseError(
-                        'Configuration type must be one of directory, file, string, ' .
-                        'mask, set, or password');
+                      'Configuration type must be one of directory, file, string, ' .
                       'mask, set, or password');
+            }
             if (!isset($var['default'])) {
                 return $this->raiseError(
+                    'Configuration information must contain a default value ("default" index)');
-                    'Configuration information must contain a default value ("default" index)');
+            }
-            } else {
-                if (is_array($var['default'])) {
+            if (is_array($var['default'])) {
-                    $real_default = '';
+                $real_default = '';
-                    foreach ($var['default'] as $config_var => $val) {
+                foreach ($var['default'] as $config_var => $val) {
-                        if (strpos($config_var, 'text') === 0) {
+                    if (strpos($config_var, 'text') === 0) {
-                            $real_default .= $val;
+                        $real_default .= $val;
-                        } elseif (strpos($config_var, 'constant') === 0) {
-                            if (defined($val)) {
-                                $real_default .= constant($val);
-                            } else {
-                                return $this->raiseError(
-                                    'Unknown constant "' . $val . '" requested in ' .
-                                    'default value for configuration variable "' .
-                                    $name . '"');
-                            }
-                        } elseif (isset($this->configuration_info[$config_var])) {
-                            $real_default .=
-                                $this->configuration_info[$config_var]['default'];
+                    } elseif (strpos($config_var, 'constant') === 0) {
-                        } else {
+                        if (!defined($val)) {
                             return $this->raiseError(
-                                'Unknown request for "' . $config_var . '" value in ' .
+                                'Unknown constant "' . $val . '" requested in ' .
                                 'default value for configuration variable "' .
+                                $name . '"');
+                        }
+                        $real_default .= constant($val);
+                    } elseif (isset($this->configuration_info[$config_var])) {
+                        $real_default .=
+                            $this->configuration_info[$config_var]['default'];
+                    } else {
+                        return $this->raiseError(
+                            'Unknown request for "' . $config_var . '" value in ' .
-                                $name . '"');
+                            'default value for configuration variable "' .
-                        }
-                    }
-                    $var['default'] = $real_default;
-                }
-                if ($var['type'] == 'integer') {
+                            $name . '"');
+                    }
                     $var['default'] = (integer) $var['default'];
+                $var['default'] = $real_default;
+            }
+            if ($var['type'] == 'integer') {
+                $var['default'] = (integer) $var['default'];
+            }
             if (!isset($var['doc'])) {
                 return $this->raiseError(
+                    'Configuration information must contain a summary ("doc" index)');
                     'Configuration information must contain a summary ("doc" index)');
             if (!isset($var['prompt'])) {
                 return $this->raiseError(
+                    'Configuration information must contain a simple prompt ("prompt" index)');
                     'Configuration information must contain a simple prompt ("prompt" index)');
             if (!isset($var['group'])) {
                 return $this->raiseError(
+                    'Configuration information must contain a simple group ("group" index)');
                     'Configuration information must contain a simple group ("group" index)');
             if (isset($this->configuration_info[$name])) {
                 return $this->raiseError('Configuration variable "' . $name .
+                    '" already exists');
                     '" already exists');
             $this->configuration_info[$name] = $var;
             // fix bug #7351: setting custom config variable in a channel fails
+            $this->_channelConfigInfo[] = $name;
             $this->_channelConfigInfo[] = $name;
-        return true;
-    }
         return true;
     // {{{ _encodeOutput(&data)
     /**
      * Encodes/scrambles configuration data before writing to files.
      * Currently, 'password' values will be base64-encoded as to avoid
-     * that people spot cleartext passwords by accident.
      * that people spot cleartext passwords by accident.
-     * @param array (reference) array to encode values in
+     *
-     * @return bool TRUE on success
+     * @param array (reference) array to encode values in
      * @return bool TRUE on success
      * @access private
      */
     function _encodeOutput(&$data)
+    {
         foreach ($data as $key => $value) {
             if ($key == '__channels') {
                 foreach ($data['__channels'] as $channel => $blah) {
+                    $this->_encodeOutput($data['__channels'][$channel]);
                     $this->_encodeOutput($data['__channels'][$channel]);
+            }
+            if (!isset($this->configuration_info[$key])) {
-            if (!isset($this->configuration_info[$key])) {
+                continue;
                 continue;
             $type = $this->configuration_info[$key]['type'];
             switch ($type) {
                     $data[$key] = octdec($data[$key]);
                     break;
+                }
+            }
+        }
         return true;
+    }
-    // }}}
-    // {{{ _decodeInput(&data)
     /**
      * Decodes/unscrambles configuration data after reading from files.
+     *
-     * @param array (reference) array to encode values in
      * @param array (reference) array to encode values in
-     * @return bool TRUE on success
      * @return bool TRUE on success
      * @access private
+     *
      * @see PEAR_Config::_encodeOutput
      */
     function _decodeInput(&$data)
+    {
         if (!is_array($data)) {
             return true;
+        }
         foreach ($data as $key => $value) {
             if ($key == '__channels') {
                 foreach ($data['__channels'] as $channel => $blah) {
                     $this->_decodeInput($data['__channels'][$channel]);
+                }
+            }
             if (!isset($this->configuration_info[$key])) {
                 continue;
+            }
             $type = $this->configuration_info[$key]['type'];
             switch ($type) {
                 case 'password': {
                     $data[$key] = base64_decode($data[$key]);
                     $data[$key] = decoct($data[$key]);
                     break;
+                }
+            }
+        }
         return true;
+    }
-    // }}}
     // {{{ getDefaultChannel([layer])
     /**
      * Retrieve the default channel.
+     *
      * On startup, channels are not initialized, so if the default channel is not
+                }
+            }
         } elseif (isset($this->configuration[$layer]['default_channel'])) {
             $ret = $this->configuration[$layer]['default_channel'];
+        }
         if ($ret == 'pear.php.net' && defined('PEAR_RUNTYPE') && PEAR_RUNTYPE == 'pecl') {
             $ret = 'pecl.php.net';
+        }
         if ($ret) {
             if ($ret != 'pear.php.net') {
                 $this->_lazyChannelSetup();
+            }
             return $ret;
+        }
         return PEAR_CONFIG_DEFAULT_CHANNEL;
+    }
     // {{{ get(key, [layer])
     /**
      * Returns a configuration value, prioritizing layers as per the
      * layers property.
+     *
-     * @param string config key
      * @param string config key
-     * @return mixed the config value, or NULL if not found
      * @return mixed the config value, or NULL if not found
      * @access public
      */
     function get($key, $layer = null, $channel = false)
+    {
         if (!isset($this->configuration_info[$key])) {
             return null;
+        }
         if ($key == '__channels') {
             return null;
+        }
         if ($key == 'default_channel') {
             return $this->getDefaultChannel($layer);
+        }
         if (!$channel) {
             $channel = $this->getDefaultChannel();
         } elseif ($channel != 'pear.php.net') {
             $this->_lazyChannelSetup();
+        }
         $channel = strtolower($channel);
         $test = (in_array($key, $this->_channelConfigInfo)) ?
             $this->_getChannelValue($key, $layer, $channel) :
             null;
         if ($test !== null) {
                     return $this->_prependPath($test, $this->_installRoot);
+                }
+            }
             return $test;
+        }
         if ($layer === null) {
             foreach ($this->layers as $layer) {
                 if (isset($this->configuration[$layer][$key])) {
                     $test = $this->configuration[$layer][$key];
                     if ($this->_installRoot) {
                               array('File Locations', 'File Locations (Advanced)')) &&
                               $this->getType($key) == 'directory') {
                             return $this->_prependPath($test, $this->_installRoot);
+                        }
+                    }
                     if ($key == 'preferred_mirror') {
                         $reg = &$this->getRegistry();
                         if (is_object($reg)) {
-                            $chan = &$reg->getChannel($channel);
+                            $chan = $reg->getChannel($channel);
                             if (PEAR::isError($chan)) {
                                 return $channel;
+                            }
                             if (!$chan->getMirror($test) && $chan->getName() != $test) {
                                 return $channel; // mirror does not exist
+                            }
+                        }
+                    }
                       array('File Locations', 'File Locations (Advanced)')) &&
                       $this->getType($key) == 'directory') {
                     return $this->_prependPath($test, $this->_installRoot);
+                }
+            }
             if ($key == 'preferred_mirror') {
                 $reg = &$this->getRegistry();
                 if (is_object($reg)) {
-                    $chan = &$reg->getChannel($channel);
+                    $chan = $reg->getChannel($channel);
                     if (PEAR::isError($chan)) {
                         return $channel;
+                    }
                     if (!$chan->getMirror($test) && $chan->getName() != $test) {
                         return $channel; // mirror does not exist
+                    }
+                }
+            }
             return $test;
+        }
         return null;
+    }
-    // }}}
     // {{{ _getChannelValue(key, value, [layer])
     /**
      * Returns a channel-specific configuration value, prioritizing layers as per the
      * layers property.
+     *
-     * @param string config key
      * @param string config key
-     * @return mixed the config value, or NULL if not found
      * @return mixed the config value, or NULL if not found
      * @access private
      */
     function _getChannelValue($key, $layer, $channel)
+    {
         if ($key == '__channels' || $channel == 'pear.php.net') {
             return null;
+        }
         $ret = null;
         if ($layer === null) {
             foreach ($this->layers as $ilayer) {
                 if (isset($this->configuration[$ilayer]['__channels'][$channel][$key])) {
+                }
+            }
         } elseif (isset($this->configuration[$layer]['__channels'][$channel][$key])) {
             $ret = $this->configuration[$layer]['__channels'][$channel][$key];
+        }
-        if ($key == 'preferred_mirror') {
+        if ($key != 'preferred_mirror') {
+            return $ret;
+        }
-            if ($ret !== null) {
+        if ($ret !== null) {
-                $reg = &$this->getRegistry($layer);
+            $reg = &$this->getRegistry($layer);
-                if (is_object($reg)) {
+            if (is_object($reg)) {
-                    $chan = &$reg->getChannel($channel);
+                $chan = $reg->getChannel($channel);
-                    if (PEAR::isError($chan)) {
+                if (PEAR::isError($chan)) {
-                        return $channel;
+                    return $channel;
-                    }
+                }
-                    if (!$chan->getMirror($ret) && $chan->getName() != $ret) {
+                if (!$chan->getMirror($ret) && $chan->getName() != $ret) {
-                        return $channel; // mirror does not exist
+                    return $channel; // mirror does not exist
-                    }
+                }
-                return $ret;
-            }
-            if ($channel != $this->getDefaultChannel($layer)) {
-                return $channel; // we must use the channel name as the preferred mirror
-                                 // if the user has not chosen an alternate
-            } else {
-                return $this->getDefaultChannel($layer);
+            }
+            return $ret;
+        }
-        return $ret;
-    }
+        if ($channel != $this->getDefaultChannel($layer)) {
+            return $channel; // we must use the channel name as the preferred mirror
+                             // if the user has not chosen an alternate
+        }
-    // }}}
+        return $this->getDefaultChannel($layer);
     // {{{ set(key, value, [layer])
     /**
     function set($key, $value, $layer = 'user', $channel = false)
+    {
         if ($key == '__channels') {
             return false;
+        }
         if (!isset($this->configuration[$layer])) {
             return false;
+        }
         if ($key == 'default_channel') {
             // can only set this value globally
             $channel = 'pear.php.net';
             if ($value != 'pear.php.net') {
                 $this->_lazyChannelSetup($layer);
+            }
+        }
         if ($key == 'preferred_mirror') {
             if ($channel == '__uri') {
                 return false; // can't set the __uri pseudo-channel's mirror
+            }
             $reg = &$this->getRegistry($layer);
             if (is_object($reg)) {
-                $chan = &$reg->getChannel($channel ? $channel : 'pear.php.net');
+                $chan = $reg->getChannel($channel ? $channel : 'pear.php.net');
                 if (PEAR::isError($chan)) {
                     return false;
+                }
                 if (!$chan->getMirror($value) && $chan->getName() != $value) {
                     return false; // mirror does not exist
+                }
+            }
+        }
-        if (empty($this->configuration_info[$key])) {
+        if (!isset($this->configuration_info[$key])) {
             return false;
+        }
         extract($this->configuration_info[$key]);
         switch ($type) {
             case 'integer':
                 $value = (int)$value;
                 break;
+                    }
+                }
                 break;
+            }
+        }
         if (!$channel) {
             $channel = $this->get('default_channel', null, 'pear.php.net');
+        }
         if (!in_array($channel, $this->_channels)) {
             $this->_lazyChannelSetup($layer);
             $reg = &$this->getRegistry($layer);
             if ($reg) {
                 $channel = $reg->channelName($channel);
+            }
             if (!in_array($channel, $this->_channels)) {
                 return false;
+            }
+        }
         if ($channel != 'pear.php.net') {
             if (in_array($key, $this->_channelConfigInfo)) {
                 $this->configuration[$layer]['__channels'][$channel][$key] = $value;
                 return true;
-            } else {
-                return false;
+            }
+            return false;
-        } else {
+        }
-            if ($key == 'default_channel') {
+        if ($key == 'default_channel') {
-                if (!isset($reg)) {
+            if (!isset($reg)) {
-                    $reg = &$this->getRegistry($layer);
+                $reg = &$this->getRegistry($layer);
-                    if (!$reg) {
+                if (!$reg) {
-                        $reg = &$this->getRegistry();
+                    $reg = &$this->getRegistry();
-                    }
-                }
-                if ($reg) {
-                    $value = $reg->channelName($value);
-                }
-                if (!$value) {
-                    return false;
+                }
+            }
+            if ($reg) {
+                $value = $reg->channelName($value);
+            }
+            if (!$value) {
+                return false;
+            }
+        }
         $this->configuration[$layer][$key] = $value;
         if ($key == 'php_dir' && !$this->_noRegistry) {
             if (!isset($this->_registry[$layer]) ||
                   $value != $this->_registry[$layer]->install_dir) {
-                $this->_registry[$layer] = &new PEAR_Registry($value);
+                $this->_registry[$layer] = new PEAR_Registry($value);
                 $this->_regInitialized[$layer] = false;
-                $this->_registry[$layer]->setConfig($this);
+                $this->_registry[$layer]->setConfig($this, false);
+            }
+        }
         return true;
+    }
     // }}}
     function _lazyChannelSetup($uselayer = false)
+    {
         if ($this->_noRegistry) {
             return;
+        }
         $merge = false;
         foreach ($this->_registry as $layer => $p) {
             if ($uselayer && $uselayer != $layer) {
                 continue;
+            }
             if (!$this->_regInitialized[$layer]) {
                 if ($layer == 'default' && isset($this->_registry['user']) ||
                       isset($this->_registry['system'])) {
                     // only use the default registry if there are no alternatives
                     continue;
+                }
                 if (!is_object($this->_registry[$layer])) {
                     if ($phpdir = $this->get('php_dir', $layer, 'pear.php.net')) {
+                        $this->_registry[$layer] = new PEAR_Registry(
+                            $phpdir, false, false,
-                        $this->_registry[$layer] = &new PEAR_Registry($phpdir);
+                            $this->get('metadata_dir', $layer, 'pear.php.net'));
-                        $this->_registry[$layer]->setConfig($this);
+                        $this->_registry[$layer]->setConfig($this, false);
                         $this->_regInitialized[$layer] = false;
                     } else {
                         unset($this->_registry[$layer]);
                         return;
+                    }
+                }
                 $this->setChannels($this->_registry[$layer]->listChannels(), $merge);
                 $this->_regInitialized[$layer] = true;
                 $merge = true;
+            }
+        }
-    }
-    // {{{ setChannels()
+    }
     /**
      * Set the list of channels.
+     *
      * This should be set via a call to {@link PEAR_Registry::listChannels()}
     function setChannels($channels, $merge = false)
+    {
         if (!is_array($channels)) {
             return false;
+        }
         if ($merge) {
             $this->_channels = array_merge($this->_channels, $channels);
         } else {
             $this->_channels = $channels;
+        }
         foreach ($channels as $channel) {
             $channel = strtolower($channel);
             if ($channel == 'pear.php.net') {
                 continue;
+            }
             foreach ($this->layers as $layer) {
                 if (!isset($this->configuration[$layer]['__channels'])) {
                     $this->configuration[$layer]['__channels'] = array();
+                }
                 if (!isset($this->configuration[$layer]['__channels'][$channel])
                       || !is_array($this->configuration[$layer]['__channels'][$channel])) {
                     $this->configuration[$layer]['__channels'][$channel] = array();
+                }
+            }
+        }
         return true;
+    }
-    // }}}
-    // {{{ getType(key)
     /**
      * Get the type of a config value.
+     *
      * @param string  config key
             return $this->configuration_info[$key]['type'];
+        }
         return false;
+    }
-    // }}}
-    // {{{ getDocs(key)
     /**
      * Get the documentation for a config value.
+     *
-     * @param string  config key
      * @param string  config key
      * @return string documentation string
+     *
      * @access public
+     *
      */
     function getDocs($key)
+    {
         if (isset($this->configuration_info[$key])) {
             return $this->configuration_info[$key]['doc'];
+        }
         return false;
-    }
-       // }}}
     // {{{ getPrompt(key)
     /**
      * Get the short documentation for a config value.
-     *
      * @param string  config key
      * @param string  config key
      * @return string short documentation string
+     *
      * @access public
+     *
      */
     function getPrompt($key)
+    {
         if (isset($this->configuration_info[$key])) {
+            return $this->configuration_info[$key]['prompt'];
             return $this->configuration_info[$key]['prompt'];
-        return false;
-    }
-    // }}}
+        return false;
     // {{{ getGroup(key)
     /**
-     * Get the parameter group for a config key.
      * Get the parameter group for a config key.
      * @param string  config key
      * @param string  config key
      * @return string parameter group
+     *
      * @access public
+     *
      */
     function getGroup($key)
+    {
+        if (isset($this->configuration_info[$key])) {
-        if (isset($this->configuration_info[$key])) {
+            return $this->configuration_info[$key]['group'];
             return $this->configuration_info[$key]['group'];
-        }
-        return false;
-    }
-    // }}}
+        return false;
     // {{{ getGroups()
     /**
+    {
         $tmp = array();
         foreach ($this->configuration_info as $key => $info) {
             $tmp[$info['group']] = 1;
+        }
         return array_keys($tmp);
+    }
-    // }}}
-    // {{{ getGroupKeys()
     /**
      * Get the list of the parameters in a group.
+     *
-     * @param string $group parameter group
      * @param string $group parameter group
      * @return array list of parameters in $group
+     *
      * @access public
+     *
         foreach ($this->configuration_info as $key => $info) {
             if ($info['group'] == $group) {
                 $keys[] = $key;
+            }
+        }
         return $keys;
+    }
-    // }}}
-    // {{{ getSetValues(key)
     /**
      * Get the list of allowed set values for a config value.  Returns
      * NULL for config values that are not sets.
+     *
-     * @param string  config key
      * @param string  config key
      * @return array enumerated array of set values, or NULL if the
      *               config key is unknown or not a set
+     *
      * @access public
             $valid_set = $this->configuration_info[$key]['valid_set'];
             reset($valid_set);
             if (key($valid_set) === 0) {
                 return $valid_set;
+            }
             return array_keys($valid_set);
+        }
         return null;
+    }
-    // }}}
-    // {{{ getKeys()
     /**
      * Get all the current config keys.
+     *
      * @return array simple array of config keys
             if (isset($test['__channels'])) {
                 foreach ($test['__channels'] as $channel => $configs) {
                     $keys = array_merge($keys, $configs);
+                }
+            }
             unset($test['__channels']);
             $keys = array_merge($keys, $test);
+        }
         return array_keys($keys);
+    }
-    // }}}
-    // {{{ remove(key, [layer])
     /**
      * Remove the a config key from a specific config layer.
+     *
-     * @param string config key
      * @param string config key
      * @param string (optional) config layer
      * @param string (optional) channel (defaults to default channel)
      * @return bool TRUE on success, FALSE on failure
+     *
      * @access public
      */
-    function remove($key, $layer = 'user')
+    function remove($key, $layer = 'user', $channel = null)
+    {
-    {
+        if ($channel === null) {
+            $channel = $this->getDefaultChannel();
+        }
         $channel = $this->getDefaultChannel();
         if ($channel !== 'pear.php.net') {
             if (isset($this->configuration[$layer]['__channels'][$channel][$key])) {
                 unset($this->configuration[$layer]['__channels'][$channel][$key]);
                 return true;
+            }
+        }
         if (isset($this->configuration[$layer][$key])) {
             unset($this->configuration[$layer][$key]);
             return true;
+        }
         return false;
-    }
-    // }}}
     // {{{ removeLayer(layer)
     /**
      * Temporarily remove an entire config layer.  USE WITH CARE!
-     *
      * @param string config key
-     *
-     * @param string (optional) config layer
+     * @param string config key
      * @param string (optional) config layer
      * @return bool TRUE on success, FALSE on failure
+     *
      * @access public
      */
     function removeLayer($layer)
+    {
         if (isset($this->configuration[$layer])) {
             $this->configuration[$layer] = array();
+            return true;
             return true;
-        return false;
-    }
-    // }}}
+        return false;
     // {{{ store([layer])
     /**
-     * Stores configuration data in a layer.
      * Stores configuration data in a layer.
      * @param string config layer to store
      * @param string config layer to store
      * @return bool TRUE on success, or PEAR error on failure
+     *
      * @access public
      */
     function store($layer = 'user', $data = null)
-    {
-        return $this->writeConfigFile(null, $layer, $data);
-    }
-    // }}}
-    // {{{ toDefault(key)
-    /**
-     * Unset the user-defined value of a config key, reverting the
-     * value to the system-defined one.
-     *
-     * @param string config key
-     *
-     * @return bool TRUE on success, FALSE on failure
-     *
-     * @access public
-     */
-    function toDefault($key)
-    {
-        trigger_error("PEAR_Config::toDefault() deprecated, use PEAR_Config::remove() instead", E_USER_NOTICE);
-        return $this->remove($key, 'user');
-    }
+    {
-    // }}}
+        return $this->writeConfigFile(null, $layer, $data);
     // {{{ definedBy(key)
     /**
                         return array('layer' => $layer, 'channel' => $channel);
+                    }
                     return $layer;
+                }
+            }
             if (isset($this->configuration[$layer][$key])) {
                 if ($returnchannel) {
                     return array('layer' => $layer, 'channel' => 'pear.php.net');
+                }
                 return $layer;
+            }
+        }
-        return '';
-    }
-    // }}}
-    // {{{ isDefaulted(key)
-    /**
-     * Tells whether a config value has a system-defined value.
-     *
-     * @param string   config key
-     *
-     * @return bool
-     *
-     * @access public
-     *
-     * @deprecated
-     */
-    function isDefaulted($key)
-    {
-        trigger_error("PEAR_Config::isDefaulted() deprecated, use PEAR_Config::definedBy() instead", E_USER_NOTICE);
-        return $this->definedBy($key) == 'system';
+        return '';
-    }
-    // }}}
     // {{{ isDefined(key)
     /**
      * Tells whether a given key exists as a config value.
-     *
      * @param string config key
      * @param string config key
      * @return bool whether <config key> exists in this object
+     *
      * @access public
         foreach ($this->layers as $layer) {
             if (isset($this->configuration[$layer][$key])) {
                 return true;
+            }
+        }
         return false;
+    }
-    // }}}
-    // {{{ isDefinedLayer(key)
     /**
      * Tells whether a given config layer exists.
+     *
-     * @param string config layer
      * @param string config layer
      * @return bool whether <config layer> exists in this object
+     *
      * @access public
      */
     function isDefinedLayer($layer)
+    {
         return isset($this->configuration[$layer]);
-    }
-    // }}}
     // {{{ getLayers()
     /**
      * Returns the layers defined (except the 'default' one)
+     *
         $cf = $this->configuration;
         unset($cf['default']);
         return array_keys($cf);
+    }
-    // }}}
     // {{{ apiVersion()
     function apiVersion()
+    {
         return '1.1';
-    }
     // }}}
     /**
      * @return PEAR_Registry
      */
     function &getRegistry($use = null)
-    {
-        if ($use === null) {
-            $layer = 'user';
-        } else {
             $layer = $use;
         $layer = $use === null ? 'user' : $use;
         if (isset($this->_registry[$layer])) {
             return $this->_registry[$layer];
         } elseif ($use === null && isset($this->_registry['system'])) {
             return $this->_registry['system'];
         } elseif ($use === null && isset($this->_registry['default'])) {
             return $this->_registry['default'];
         } elseif ($use) {
-            $a = false;
-            return $a;
-        } else {
-            // only go here if null was passed in
-            echo "CRITICAL ERROR: Registry could not be initialized from any value";
+            $a = false;
+            return $a;
+        }
+        // only go here if null was passed in
-            exit(1);
+        echo "CRITICAL ERROR: Registry could not be initialized from any value";
+        exit(1);
+    }
     /**
      * This is to allow customization like the use of installroot
      * @param PEAR_Registry
      * @return bool
      */
     function setRegistry(&$reg, $layer = 'user')
+    {
         if ($this->_noRegistry) {
+            return false;
             return false;
         if (!in_array($layer, array('user', 'system'))) {
+            return false;
             return false;
         $this->_registry[$layer] = &$reg;
         if (is_object($reg)) {
+            $this->_registry[$layer]->setConfig($this, false);
             $this->_registry[$layer]->setConfig($this);
         return true;
+    }
     function noRegistry()
+    {
-        $this->_noRegistry = true;
-    }
-    /**
-     * @return PEAR_Remote
-     */
-    function &getRemote()
-    {
-        $remote = &new PEAR_Remote($this);
-        return $remote;
+        $this->_noRegistry = true;
+    }
     /**
      * @return PEAR_REST
      */
     function &getREST($version, $options = array())
+    {
+        $version = str_replace('.', '', $version);
-        $version = str_replace('.', '', $version);
+        if (!class_exists($class = 'PEAR_REST_' . $version)) {
-        if (!class_exists($class = 'PEAR_REST_' . $version)) {
+            require_once 'PEAR/REST/' . $version . '.php';
             require_once 'PEAR/REST/' . $version . '.php';
-        $remote = &new $class($this, $options);
+        $remote = new $class($this, $options);
      */
     function &getFTP()
+    {
         if (isset($this->_ftp)) {
             return $this->_ftp;
-        } else {
-            $a = false;
-            return $a;
+        }
-    }
+        $a = false;
+        return $a;
     // {{{ _prependPath($path, $prepend)
     function _prependPath($path, $prepend)
+    {
                 $path = $prepend . $path;
+            }
+        }
         return $path;
+    }
-    // }}}
     /**
      * @param string|false installation directory to prepend to all _dir variables, or false to
      *                     disable
             foreach (array_keys($this->_registry) as $layer) {
                 if ($layer == 'ftp' || !isset($this->_registry[$layer])) {
                     continue;
+                }
                 $this->_registry[$layer] =
+                    new PEAR_Registry(
+                        $this->get('php_dir', $layer, 'pear.php.net'), false, false,
-                    &new PEAR_Registry($this->get('php_dir', $layer, 'pear.php.net'));
+                        $this->get('metadata_dir', $layer, 'pear.php.net'));
-                $this->_registry[$layer]->setConfig($this);
+                $this->_registry[$layer]->setConfig($this, false);
                 $this->_regInitialized[$layer] = false;
+            }
+        }
+    }
+}
-?>

Subversion Repositories Applications.gtt

(root)/trunk/bibliotheque/pear/PEAR/Config.php – Rev 94 → 187