PEAR
[ class tree: PEAR ] [ index: PEAR ] [ all elements ]

Source for file Role.php

Documentation is available at Role.php

  1. <?php
  2. /**
  3.  * PEAR_Installer_Role
  4.  *
  5.  * PHP versions 4 and 5
  6.  *
  7.  * @category   pear
  8.  * @package    PEAR
  9.  * @author     Greg Beaver <cellog@php.net>
  10.  * @copyright  1997-2009 The Authors
  11.  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
  12.  * @version    CVS: $Id: Role.php 313023 2011-07-06 19:17:11Z dufuz $
  13.  * @link       http://pear.php.net/package/PEAR
  14.  * @since      File available since Release 1.4.0a1
  15.  */
  16.  
  17. /**
  18.  * base class for installer roles
  19.  */
  20. require_once 'PEAR/Installer/Role/Common.php';
  21. require_once 'PEAR/XMLParser.php';
  22. /**
  23.  * @category   pear
  24.  * @package    PEAR
  25.  * @author     Greg Beaver <cellog@php.net>
  26.  * @copyright  1997-2009 The Authors
  27.  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
  28.  * @version    Release: 1.9.4
  29.  * @link       http://pear.php.net/package/PEAR
  30.  * @since      Class available since Release 1.4.0a1
  31.  */
  32. {
  33.     /**
  34.      * Set up any additional configuration variables that file roles require
  35.      *
  36.      * Never call this directly, it is called by the PEAR_Config constructor
  37.      * @param PEAR_Config 
  38.      * @access private
  39.      * @static
  40.      */
  41.     function initializeConfig(&$config)
  42.     {
  43.         if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
  44.             PEAR_Installer_Role::registerRoles();
  45.         }
  46.  
  47.         foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'as $class => $info{
  48.             if (!$info['config_vars']{
  49.                 continue;
  50.             }
  51.  
  52.             $config->_addConfigVars($class$info['config_vars']);
  53.         }
  54.     }
  55.  
  56.     /**
  57.      * @param PEAR_PackageFile_v2 
  58.      * @param string role name
  59.      * @param PEAR_Config 
  60.      * @return PEAR_Installer_Role_Common 
  61.      * @static
  62.      */
  63.     function &factory($pkg$role&$config)
  64.     {
  65.         if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
  66.             PEAR_Installer_Role::registerRoles();
  67.         }
  68.  
  69.         if (!in_array($rolePEAR_Installer_Role::getValidRoles($pkg->getPackageType()))) {
  70.             $a = false;
  71.             return $a;
  72.         }
  73.  
  74.         $a 'PEAR_Installer_Role_' ucfirst($role);
  75.         if (!class_exists($a)) {
  76.             require_once str_replace('_''/'$a'.php';
  77.         }
  78.  
  79.         $b = new $a($config);
  80.         return $b;
  81.     }
  82.  
  83.     /**
  84.      * Get a list of file roles that are valid for the particular release type.
  85.      *
  86.      * For instance, src files serve no purpose in regular php releases.
  87.      * @param string 
  88.      * @param bool clear cache
  89.      * @return array 
  90.      * @static
  91.      */
  92.     function getValidRoles($release$clear = false)
  93.     {
  94.         if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
  95.             PEAR_Installer_Role::registerRoles();
  96.         }
  97.  
  98.         static $ret = array();
  99.         if ($clear{
  100.             $ret = array();
  101.         }
  102.  
  103.         if (isset($ret[$release])) {
  104.             return $ret[$release];
  105.         }
  106.  
  107.         $ret[$release= array();
  108.         foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'as $role => $okreleases{
  109.             if (in_array($release$okreleases['releasetypes'])) {
  110.                 $ret[$release][= strtolower(str_replace('PEAR_Installer_Role_'''$role));
  111.             }
  112.         }
  113.  
  114.         return $ret[$release];
  115.     }
  116.  
  117.     /**
  118.      * Get a list of roles that require their files to be installed
  119.      *
  120.      * Most roles must be installed, but src and package roles, for instance
  121.      * are pseudo-roles.  src files are compiled into a new extension.  Package
  122.      * roles are actually fully bundled releases of a package
  123.      * @param bool clear cache
  124.      * @return array 
  125.      * @static
  126.      */
  127.     function getInstallableRoles($clear = false)
  128.     {
  129.         if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
  130.             PEAR_Installer_Role::registerRoles();
  131.         }
  132.  
  133.         static $ret;
  134.         if ($clear{
  135.             unset($ret);
  136.         }
  137.  
  138.         if (isset($ret)) {
  139.             return $ret;
  140.         }
  141.  
  142.         $ret = array();
  143.         foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'as $role => $okreleases{
  144.             if ($okreleases['installable']{
  145.                 $ret[strtolower(str_replace('PEAR_Installer_Role_'''$role));
  146.             }
  147.         }
  148.  
  149.         return $ret;
  150.     }
  151.  
  152.     /**
  153.      * Return an array of roles that are affected by the baseinstalldir attribute
  154.      *
  155.      * Most roles ignore this attribute, and instead install directly into:
  156.      * PackageName/filepath
  157.      * so a tests file tests/file.phpt is installed into PackageName/tests/filepath.php
  158.      * @param bool clear cache
  159.      * @return array 
  160.      * @static
  161.      */
  162.     function getBaseinstallRoles($clear = false)
  163.     {
  164.         if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
  165.             PEAR_Installer_Role::registerRoles();
  166.         }
  167.  
  168.         static $ret;
  169.         if ($clear{
  170.             unset($ret);
  171.         }
  172.  
  173.         if (isset($ret)) {
  174.             return $ret;
  175.         }
  176.  
  177.         $ret = array();
  178.         foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'as $role => $okreleases{
  179.             if ($okreleases['honorsbaseinstall']{
  180.                 $ret[strtolower(str_replace('PEAR_Installer_Role_'''$role));
  181.             }
  182.         }
  183.  
  184.         return $ret;
  185.     }
  186.  
  187.     /**
  188.      * Return an array of file roles that should be analyzed for PHP content at package time,
  189.      * like the "php" role.
  190.      * @param bool clear cache
  191.      * @return array 
  192.      * @static
  193.      */
  194.     function getPhpRoles($clear = false)
  195.     {
  196.         if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
  197.             PEAR_Installer_Role::registerRoles();
  198.         }
  199.  
  200.         static $ret;
  201.         if ($clear{
  202.             unset($ret);
  203.         }
  204.  
  205.         if (isset($ret)) {
  206.             return $ret;
  207.         }
  208.  
  209.         $ret = array();
  210.         foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'as $role => $okreleases{
  211.             if ($okreleases['phpfile']{
  212.                 $ret[strtolower(str_replace('PEAR_Installer_Role_'''$role));
  213.             }
  214.         }
  215.  
  216.         return $ret;
  217.     }
  218.  
  219.     /**
  220.      * Scan through the Command directory looking for classes
  221.      * and see what commands they implement.
  222.      * @param string which directory to look for classes, defaults to
  223.      *                the Installer/Roles subdirectory of
  224.      *                the directory from where this file (__FILE__) is
  225.      *                included.
  226.      *
  227.      * @return bool TRUE on success, a PEAR error on failure
  228.      * @access public
  229.      * @static
  230.      */
  231.     function registerRoles($dir = null)
  232.     {
  233.         $GLOBALS['_PEAR_INSTALLER_ROLES'= array();
  234.         $parser = new PEAR_XMLParser;
  235.         if ($dir === null{
  236.             $dir dirname(__FILE__'/Role';
  237.         }
  238.  
  239.         if (!file_exists($dir|| !is_dir($dir)) {
  240.             return PEAR::raiseError("registerRoles: opendir($dir) failed: does not exist/is not directory");
  241.         }
  242.  
  243.         $dp @opendir($dir);
  244.         if (empty($dp)) {
  245.             return PEAR::raiseError("registerRoles: opendir($dir) failed: $php_errmsg");
  246.         }
  247.  
  248.         while ($entry readdir($dp)) {
  249.             if ($entry{0== '.' || substr($entry-4!= '.xml'{
  250.                 continue;
  251.             }
  252.  
  253.             $class "PEAR_Installer_Role_".substr($entry0-4);
  254.             // List of roles
  255.             if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'][$class])) {
  256.                 $file = "$dir/$entry";
  257.                 $parser->parse(file_get_contents($file));
  258.                 $data $parser->getData();
  259.                 if (!is_array($data['releasetypes'])) {
  260.                     $data['releasetypes'= array($data['releasetypes']);
  261.                 }
  262.  
  263.                 $GLOBALS['_PEAR_INSTALLER_ROLES'][$class$data;
  264.             }
  265.         }
  266.  
  267.         closedir($dp);
  268.         ksort($GLOBALS['_PEAR_INSTALLER_ROLES']);
  269.         PEAR_Installer_Role::getPhpRoles(true);
  270.         PEAR_Installer_Role::getValidRoles('****'true);
  271.         return true;
  272.     }
  273. }

Documentation generated on Wed, 06 Jul 2011 23:31:18 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.