Subversion Repositories Applications.gtt

<?php

//

// +----------------------------------------------------------------------+

// | PHP Version 5                                                        |

// +----------------------------------------------------------------------+

// | Copyright (c) 1997-2004 The PHP Group                                |

// +----------------------------------------------------------------------+

// | This source file is subject to version 3.0 of the PHP license,       |

// | that is bundled with this package in the file LICENSE, and is        |

// | available through the world-wide-web at the following url:           |

// | 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 world-wide-web, please send a note to          |

// | license@php.net so we can mail you a copy immediately.               |

// +----------------------------------------------------------------------+

// | Authors: Tomas V.V.Cox <cox@idecnet.com>                             |

// |          Stig Bakken <ssb@php.net>                                   |

// +----------------------------------------------------------------------+

//

// THIS FILE IS DEPRECATED IN FAVOR OF DEPENDENCY2.PHP, AND IS NOT USED IN THE INSTALLER

// $Id: Dependency.php,v 1.42 2006/03/26 23:25:56 cellog Exp $

require_once "PEAR.php";

require_once "OS/Guess.php";

define('PEAR_DEPENDENCY_MISSING',        -1);

define('PEAR_DEPENDENCY_CONFLICT',       -2);

define('PEAR_DEPENDENCY_UPGRADE_MINOR',  -3);

define('PEAR_DEPENDENCY_UPGRADE_MAJOR',  -4);

define('PEAR_DEPENDENCY_BAD_DEPENDENCY', -5);

define('PEAR_DEPENDENCY_MISSING_OPTIONAL', -6);

define('PEAR_DEPENDENCY_CONFLICT_OPTIONAL',       -7);

define('PEAR_DEPENDENCY_UPGRADE_MINOR_OPTIONAL',  -8);

define('PEAR_DEPENDENCY_UPGRADE_MAJOR_OPTIONAL',  -9);

/**

 * Dependency check for PEAR packages

 *

 * The class is based on the dependency RFC that can be found at

 * http://cvs.php.net/cvs.php/pearweb/rfc. It requires PHP >= 4.1

 *

 * @author Tomas V.V.Vox <cox@idecnet.com>

 * @author Stig Bakken <ssb@php.net>

 */

class PEAR_Dependency

{

    // {{{ constructor

    /**

     * Constructor

     *

     * @access public

     * @param  object Registry object

     * @return void

     */

    function PEAR_Dependency(&$registry)

    {

        $this->registry = &$registry;

    }

    // }}}

    // {{{ callCheckMethod()

    /**

    * This method maps the XML dependency definition to the

    * corresponding one from PEAR_Dependency

    *

    * <pre>

    * $opts => Array

    *    (

    *        [type] => pkg

    *        [rel] => ge

    *        [version] => 3.4

    *        [name] => HTML_Common

    *        [optional] => false

    *    )

    * </pre>

    *

    * @param  string Error message

    * @param  array  Options

    * @return boolean

    */

    function callCheckMethod(&$errmsg, $opts)

    {

        $rel = isset($opts['rel']) ? $opts['rel'] : 'has';

        $req = isset($opts['version']) ? $opts['version'] : null;

        $name = isset($opts['name']) ? $opts['name'] : null;

        $channel = isset($opts['channel']) ? $opts['channel'] : 'pear.php.net';

        $opt = (isset($opts['optional']) && $opts['optional'] == 'yes') ?

            $opts['optional'] : null;

        $errmsg = '';

        switch ($opts['type']) {

            case 'pkg':

                return $this->checkPackage($errmsg, $name, $req, $rel, $opt, $channel);

                break;

            case 'ext':

                return $this->checkExtension($errmsg, $name, $req, $rel, $opt);

                break;

            case 'php':

                return $this->checkPHP($errmsg, $req, $rel);

                break;

            case 'prog':

                return $this->checkProgram($errmsg, $name);

                break;

            case 'os':

                return $this->checkOS($errmsg, $name);

                break;

            case 'sapi':

                return $this->checkSAPI($errmsg, $name);

                break;

            case 'zend':

                return $this->checkZend($errmsg, $name);

                break;

            default:

                return "'{$opts['type']}' dependency type not supported";

        }

    }

    // }}}

    // {{{ checkPackage()

    /**

     * Package dependencies check method

     *

     * @param string $errmsg    Empty string, it will be populated with an error message, if any

     * @param string $name      Name of the package to test

     * @param string $req       The package version required

     * @param string $relation  How to compare versions with each other

     * @param bool   $opt       Whether the relationship is optional

     * @param string $channel   Channel name

     *

     * @return mixed bool false if no error or the error string

     */

    function checkPackage(&$errmsg, $name, $req = null, $relation = 'has',

                          $opt = false, $channel = 'pear.php.net')

    {

        if (is_string($req) && substr($req, 0, 2) == 'v.') {

            $req = substr($req, 2);

        }

        switch ($relation) {

            case 'has':

                if (!$this->registry->packageExists($name, $channel)) {

                    if ($opt) {

                        $errmsg = "package `$channel/$name' is recommended to utilize some features.";

                        return PEAR_DEPENDENCY_MISSING_OPTIONAL;

                    }

                    $errmsg = "requires package `$channel/$name'";

                    return PEAR_DEPENDENCY_MISSING;

                }

                return false;

            case 'not':

                if ($this->registry->packageExists($name, $channel)) {

                    $errmsg = "conflicts with package `$channel/$name'";

                    return PEAR_DEPENDENCY_CONFLICT;

                }

                return false;

            case 'lt':

            case 'le':

            case 'eq':

            case 'ne':

            case 'ge':

            case 'gt':

                $version = $this->registry->packageInfo($name, 'version', $channel);

                if (!$this->registry->packageExists($name, $channel)

                    || !version_compare("$version", "$req", $relation))

                {

                    $code = $this->codeFromRelation($relation, $version, $req, $opt);

                    if ($opt) {

                        $errmsg = "package `$channel/$name' version " . $this->signOperator($relation) .

                            " $req is recommended to utilize some features.";

                        if ($version) {

                            $errmsg .= "  Installed version is $version";

                        }

                        return $code;

                    }

                    $errmsg = "requires package `$channel/$name' " .

                        $this->signOperator($relation) . " $req";

                    return $code;

                }

                return false;

        }

        $errmsg = "relation '$relation' with requirement '$req' is not supported (name=$channel/$name)";

        return PEAR_DEPENDENCY_BAD_DEPENDENCY;

    }

    // }}}

    // {{{ checkPackageUninstall()

    /**

     * Check package dependencies on uninstall

     *

     * @param string $error     The resultant error string

     * @param string $warning   The resultant warning string

     * @param string $name      Name of the package to test

     * @param string $channel   Channel name of the package

     *

     * @return bool true if there were errors

     */

    function checkPackageUninstall(&$error, &$warning, $package, $channel = 'pear.php.net')

    {

        $channel = strtolower($channel);

        $error = null;

        $channels = $this->registry->listAllPackages();

        foreach ($channels as $channelname => $packages) {

            foreach ($packages as $pkg) {

                if ($pkg == $package && $channel == $channelname) {

                    continue;

                }

                $deps = $this->registry->packageInfo($pkg, 'release_deps', $channel);

                if (empty($deps)) {

                    continue;

                }

                foreach ($deps as $dep) {

                    $depchannel = isset($dep['channel']) ? $dep['channel'] : 'pear.php.net';

                    if ($dep['type'] == 'pkg' && (strcasecmp($dep['name'], $package) == 0) &&

                          ($depchannel == $channel)) {

                        if ($dep['rel'] == 'ne') {

                            continue;

                        }

                        if (isset($dep['optional']) && $dep['optional'] == 'yes') {

                            $warning .= "\nWarning: Package '$depchannel/$pkg' optionally depends on '$channel:/package'";

                        } else {

                            $error .= "Package '$depchannel/$pkg' depends on '$channel/$package'\n";

                        }

                    }

                }

            }

        }

        return ($error) ? true : false;

    }

    // }}}

    // {{{ checkExtension()

    /**

     * Extension dependencies check method

     *

     * @param string $name        Name of the extension to test

     * @param string $req_ext_ver Required extension version to compare with

     * @param string $relation    How to compare versions with eachother

     * @param bool   $opt         Whether the relationship is optional

     *

     * @return mixed bool false if no error or the error string

     */

    function checkExtension(&$errmsg, $name, $req = null, $relation = 'has',

        $opt = false)

    {

        if ($relation == 'not') {

            if (extension_loaded($name)) {

                $errmsg = "conflicts with  PHP extension '$name'";

                return PEAR_DEPENDENCY_CONFLICT;

            } else {

                return false;

            }

        }

        if (!extension_loaded($name)) {

            if ($relation == 'ne') {

                return false;

            }

            if ($opt) {

                $errmsg = "'$name' PHP extension is recommended to utilize some features";

                return PEAR_DEPENDENCY_MISSING_OPTIONAL;

            }

            $errmsg = "'$name' PHP extension is not installed";

            return PEAR_DEPENDENCY_MISSING;

        }

        if ($relation == 'has') {

            return false;

        }

        $code = false;

        if (is_string($req) && substr($req, 0, 2) == 'v.') {

            $req = substr($req, 2);

        }

        $ext_ver = phpversion($name);

        $operator = $relation;

        // Force params to be strings, otherwise the comparation will fail (ex. 0.9==0.90)

        if (!version_compare("$ext_ver", "$req", $operator)) {

            $errmsg = "'$name' PHP extension version " .

                $this->signOperator($operator) . " $req is required";

            $code = $this->codeFromRelation($relation, $ext_ver, $req, $opt);

            if ($opt) {

                $errmsg = "'$name' PHP extension version " . $this->signOperator($operator) .

                    " $req is recommended to utilize some features";

                return $code;

            }

        }

        return $code;

    }

    // }}}

    // {{{ checkOS()

    /**

     * Operating system  dependencies check method

     *

     * @param string $os  Name of the operating system

     *

     * @return mixed bool false if no error or the error string

     */

    function checkOS(&$errmsg, $os)

    {

        // XXX Fixme: Implement a more flexible way, like

        // comma separated values or something similar to PEAR_OS

        static $myos;

        if (empty($myos)) {

            $myos = new OS_Guess();

        }

        // only 'has' relation is currently supported

        if ($myos->matchSignature($os)) {

            return false;

        }

        $errmsg = "'$os' operating system not supported";

        return PEAR_DEPENDENCY_CONFLICT;

    }

    // }}}

    // {{{ checkPHP()

    /**

     * PHP version check method

     *

     * @param string $req   which version to compare

     * @param string $relation  how to compare the version

     *

     * @return mixed bool false if no error or the error string

     */

    function checkPHP(&$errmsg, $req, $relation = 'ge')

    {

        // this would be a bit stupid, but oh well :)

        if ($relation == 'has') {

            return false;

        }

        if ($relation == 'not') {

            $errmsg = "Invalid dependency - 'not' is allowed when specifying PHP, you must run PHP in PHP";

            return PEAR_DEPENDENCY_BAD_DEPENDENCY;

        }

        if (substr($req, 0, 2) == 'v.') {

            $req = substr($req,2, strlen($req) - 2);

        }

        $php_ver = phpversion();

        $operator = $relation;

        if (!version_compare("$php_ver", "$req", $operator)) {

            $errmsg = "PHP version " . $this->signOperator($operator) .

                " $req is required";

            return PEAR_DEPENDENCY_CONFLICT;

        }

        return false;

    }

    // }}}

    // {{{ checkProgram()

    /**

     * External program check method.  Looks for executable files in

     * directories listed in the PATH environment variable.

     *

     * @param string $program   which program to look for

     *

     * @return mixed bool false if no error or the error string

     */

    function checkProgram(&$errmsg, $program)

    {

        // XXX FIXME honor safe mode

        $exe_suffix = OS_WINDOWS ? '.exe' : '';

        $path_elements = explode(PATH_SEPARATOR, getenv('PATH'));

        foreach ($path_elements as $dir) {

            $file = $dir . DIRECTORY_SEPARATOR . $program . $exe_suffix;

            if (file_exists($file) && is_executable($file)) {

                return false;

            }

        }

        $errmsg = "'$program' program is not present in the PATH";

        return PEAR_DEPENDENCY_MISSING;

    }

    // }}}

    // {{{ checkSAPI()

    /**

     * SAPI backend check method.  Version comparison is not yet

     * available here.

     *

     * @param string $name      name of SAPI backend

     * @param string $req   which version to compare

     * @param string $relation  how to compare versions (currently

     *                          hardcoded to 'has')

     * @return mixed bool false if no error or the error string

     */

    function checkSAPI(&$errmsg, $name, $req = null, $relation = 'has')

    {

        // XXX Fixme: There is no way to know if the user has or

        // not other SAPI backends installed than the installer one

        $sapi_backend = php_sapi_name();

        // Version comparisons not supported, sapi backends don't have

        // version information yet.

        if ($sapi_backend == $name) {

            return false;

        }

        $errmsg = "'$sapi_backend' SAPI backend not supported";

        return PEAR_DEPENDENCY_CONFLICT;

    }

    // }}}

    // {{{ checkZend()

    /**

     * Zend version check method

     *

     * @param string $req   which version to compare

     * @param string $relation  how to compare the version

     *

     * @return mixed bool false if no error or the error string

     */

    function checkZend(&$errmsg, $req, $relation = 'ge')

    {

        if (substr($req, 0, 2) == 'v.') {

            $req = substr($req,2, strlen($req) - 2);

        }

        $zend_ver = zend_version();

        $operator = substr($relation,0,2);

        if (!version_compare("$zend_ver", "$req", $operator)) {

            $errmsg = "Zend version " . $this->signOperator($operator) .

                " $req is required";

            return PEAR_DEPENDENCY_CONFLICT;

        }

        return false;

    }

    // }}}

    // {{{ signOperator()

    /**

     * Converts text comparing operators to them sign equivalents

     *

     * Example: 'ge' to '>='

     *

     * @access public

     * @param  string Operator

     * @return string Sign equivalent

     */

    function signOperator($operator)

    {

        switch($operator) {

            case 'lt': return '<';

            case 'le': return '<=';

            case 'gt': return '>';

            case 'ge': return '>=';

            case 'eq': return '==';

            case 'ne': return '!=';

            default:

                return $operator;

        }

    }

    // }}}

    // {{{ codeFromRelation()

    /**

     * Convert relation into corresponding code

     *

     * @access public

     * @param  string Relation

     * @param  string Version

     * @param  string Requirement

     * @param  bool   Optional dependency indicator

     * @return integer

     */

    function codeFromRelation($relation, $version, $req, $opt = false)

    {

        $code = PEAR_DEPENDENCY_BAD_DEPENDENCY;

        switch ($relation) {

            case 'gt': case 'ge': case 'eq':

                // upgrade

                $have_major = preg_replace('/\D.*/', '', $version);

                $need_major = preg_replace('/\D.*/', '', $req);

                if ($need_major > $have_major) {

                    $code = $opt ? PEAR_DEPENDENCY_UPGRADE_MAJOR_OPTIONAL :

                                   PEAR_DEPENDENCY_UPGRADE_MAJOR;

                } else {

                    $code = $opt ? PEAR_DEPENDENCY_UPGRADE_MINOR_OPTIONAL :

                                   PEAR_DEPENDENCY_UPGRADE_MINOR;

                }

                break;

            case 'lt': case 'le': case 'ne':

                $code = $opt ? PEAR_DEPENDENCY_CONFLICT_OPTIONAL :

                               PEAR_DEPENDENCY_CONFLICT;

                break;

        }

        return $code;

    }

    // }}}

}

?>