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

 /**
  * PEAR_Downloader_Package
+ *
  * 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     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: Package.php,v 1.104 2007/01/14 21:11:54 cellog Exp $
  * @link       http://pear.php.net/package/PEAR
  * @since      File available since Release 1.4.0a1
  */
 /**
  * Error code when parameter initialization fails because no releases
  * exist within preferred_state, but releases do exist
  */
 define('PEAR_DOWNLOADER_PACKAGE_STATE', -1003);
 /**
+ * Error code when parameter initialization fails because no releases
+ * exist that will work with the existing PHP version
+ */
+define('PEAR_DOWNLOADER_PACKAGE_PHPVERSION', -1004);
+/**
  * Coordinates download parameters and manages their dependencies
  * prior to downloading them.
+ *
  * Input can come from three sources:
+ *
  * not supported, PEAR installer version is not supported, or non-PECL extensions are not
  * installed.
  * @category   pear
  * @package    PEAR
  * @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 1.4.0a1
  */
 class PEAR_Downloader_Package
+{
     /**
      * If this package is invoked with Package#group, this variable will be true
      */
     var $_explicitGroup = false;
     /**
-     * Package type local|url|xmlrpc
+     * Package type local|url
      * @var string
      */
     var $_type;
     /**
      * Contents of package.xml, if downloaded from a remote channel
     var $_validated = false;
     /**
      * @param PEAR_Downloader
      */
-    function PEAR_Downloader_Package(&$downloader)
+    function __construct(&$downloader)
+    {
         $this->_downloader = &$downloader;
         $this->_config = &$this->_downloader->config;
         $this->_registry = &$this->_config->getRegistry();
      * @return bool|PEAR_Error
      */
     function initialize($param)
+    {
         $origErr = $this->_fromFile($param);
-        if (!$this->_valid) {
+        if ($this->_valid) {
+            return true;
+        }
-            $options = $this->_downloader->getOptions();
+        $options = $this->_downloader->getOptions();
-            if (isset($options['offline'])) {
+        if (isset($options['offline'])) {
-                if (PEAR::isError($origErr)) {
+            if (PEAR::isError($origErr) && !isset($options['soft'])) {
+                foreach ($origErr->getUserInfo() as $userInfo) {
-                    if (!isset($options['soft'])) {
+                    if (isset($userInfo['message'])) {
-                        $this->_downloader->log(0, $origErr->getMessage());
+                        $this->_downloader->log(0, $userInfo['message']);
+                    }
+                }
-                return PEAR::raiseError('Cannot download non-local package "' . $param . '"');
+                $this->_downloader->log(0, $origErr->getMessage());
+            }
+            return PEAR::raiseError('Cannot download non-local package "' . $param . '"');
+        }
-            $err = $this->_fromUrl($param);
+        $err = $this->_fromUrl($param);
+        if (PEAR::isError($err) || !$this->_valid) {
+            if ($this->_type == 'url') {
+                if (PEAR::isError($err) && !isset($options['soft'])) {
+                    $this->_downloader->log(0, $err->getMessage());
+                }
+                return PEAR::raiseError("Invalid or missing remote package file");
+            }
+            $err = $this->_fromString($param);
             if (PEAR::isError($err) || !$this->_valid) {
-                if ($this->_type == 'url') {
-                    if (PEAR::isError($err)) {
+                if (PEAR::isError($err) && $err->getCode() == PEAR_DOWNLOADER_PACKAGE_STATE) {
-                        if (!isset($options['soft'])) {
-                            $this->_downloader->log(0, $err->getMessage());
-                        }
-                    }
-                    return PEAR::raiseError("Invalid or missing remote package file");
+                    return false; // instruct the downloader to silently skip
+                }
-                $err = $this->_fromString($param);
-                if (PEAR::isError($err) || !$this->_valid) {
-                    if (PEAR::isError($err) &&
-                          $err->getCode() == PEAR_DOWNLOADER_PACKAGE_STATE) {
-                        return false; // instruct the downloader to silently skip
-                    }
-                    if (isset($this->_type) && $this->_type == 'local' &&
+                if (isset($this->_type) && $this->_type == 'local' && PEAR::isError($origErr)) {
-                          PEAR::isError($origErr)) {
-                        if (is_array($origErr->getUserInfo())) {
+                    if (is_array($origErr->getUserInfo())) {
-                            foreach ($origErr->getUserInfo() as $err) {
+                        foreach ($origErr->getUserInfo() as $err) {
-                                if (is_array($err)) {
+                            if (is_array($err)) {
-                                    $err = $err['message'];
+                                $err = $err['message'];
-                                }
+                            }
-                                if (!isset($options['soft'])) {
+                            if (!isset($options['soft'])) {
-                                    $this->_downloader->log(0, $err);
+                                $this->_downloader->log(0, $err);
-                                }
+                            }
+                        }
-                        if (!isset($options['soft'])) {
-                            $this->_downloader->log(0, $origErr->getMessage());
-                        }
-                        if (is_array($param)) {
-                            $param = $this->_registry->parsedPackageNameToString($param,
-                                true);
-                        }
-                        return PEAR::raiseError(
-                            "Cannot initialize '$param', invalid or missing package file");
+                    }
-                    if (PEAR::isError($err)) {
-                        if (!isset($options['soft'])) {
+                    if (!isset($options['soft'])) {
-                            $this->_downloader->log(0, $err->getMessage());
+                        $this->_downloader->log(0, $origErr->getMessage());
-                        }
+                    }
                     if (is_array($param)) {
                         $param = $this->_registry->parsedPackageNameToString($param, true);
+                    }
+                    if (!isset($options['soft'])) {
+                        $this->_downloader->log(2, "Cannot initialize '$param', invalid or missing package file");
+                    }
+                    // Passing no message back - already logged above
-                    return PEAR::raiseError(
+                    return PEAR::raiseError();
+                }
+                if (PEAR::isError($err) && !isset($options['soft'])) {
+                    $this->_downloader->log(0, $err->getMessage());
+                }
+                if (is_array($param)) {
+                    $param = $this->_registry->parsedPackageNameToString($param, true);
+                }
+                if (!isset($options['soft'])) {
-                        "Cannot initialize '$param', invalid or missing package file");
+                    $this->_downloader->log(2, "Cannot initialize '$param', invalid or missing package file");
+                }
+                // Passing no message back - already logged above
+                return PEAR::raiseError();
+            }
+        }
         return true;
+    }
     /**
     function &download()
+    {
         if (isset($this->_packagefile)) {
             return $this->_packagefile;
+        }
         if (isset($this->_downloadURL['url'])) {
             $this->_isvalid = false;
             $info = $this->getParsedPackage();
             foreach ($info as $i => $p) {
                 $info[$i] = strtolower($p);
+            }
             $err = $this->_fromUrl($this->_downloadURL['url'],
                 $this->_registry->parsedPackageNameToString($this->_parsedname, true));
             $newinfo = $this->getParsedPackage();
             foreach ($newinfo as $i => $p) {
                 $newinfo[$i] = strtolower($p);
+            }
             if ($info != $newinfo) {
                 do {
-                    if ($info['package'] == 'pecl.php.net' && $newinfo['package'] == 'pear.php.net') {
+                    if ($info['channel'] == 'pecl.php.net' && $newinfo['channel'] == 'pear.php.net') {
-                        $info['package'] = 'pear.php.net';
+                        $info['channel'] = 'pear.php.net';
                         if ($info == $newinfo) {
                             // skip the channel check if a pecl package says it's a PEAR package
                             break;
+                        }
+                    }
+                    if ($info['channel'] == 'pear.php.net' && $newinfo['channel'] == 'pecl.php.net') {
+                        $info['channel'] = 'pecl.php.net';
+                        if ($info == $newinfo) {
+                            // skip the channel check if a pecl package says it's a PEAR package
+                            break;
+                        }
+                    }
                     return PEAR::raiseError('CRITICAL ERROR: We are ' .
                         $this->_registry->parsedPackageNameToString($info) . ', but the file ' .
                         'downloaded claims to be ' .
                         $this->_registry->parsedPackageNameToString($this->getParsedPackage()));
                 } while (false);
+            }
             if (PEAR::isError($err) || !$this->_valid) {
                 return $err;
+            }
+        }
         $this->_type = 'local';
         return $this->_packagefile;
+    }
     function &getDownloader()
+    {
         return $this->_downloader;
+    }
     function getType()
+    {
         return $this->_type;
+    }
             if (!extension_loaded("zlib") || isset($options['nocompress'])) {
                 $ext = '.tar';
             } else {
                 $ext = '.tgz';
+            }
             PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
             $err = $this->_fromUrl($dep['uri'] . $ext);
             PEAR::popErrorHandling();
             if (PEAR::isError($err)) {
                 if (!isset($options['soft'])) {
                     $this->_downloader->log(0, $err->getMessage());
+                }
                 return PEAR::raiseError('Invalid uri dependency "' . $dep['uri'] . $ext . '", ' .
                     'cannot download');
+            }
         } else {
             $this->_parsedname =
                 );
             if (!isset($dep['nodefault'])) {
                 $this->_parsedname['group'] = 'default'; // download the default dependency group
                 $this->_explicitGroup = false;
+            }
             $this->_rawpackagefile = $dep['raw'];
+        }
+    }
     function detectDependencies($params)
+    {
         $options = $this->_downloader->getOptions();
         if (isset($options['downloadonly'])) {
             return;
+        }
         if (isset($options['offline'])) {
             $this->_downloader->log(3, 'Skipping dependency download check, --offline specified');
             return;
+        }
         $pname = $this->getParsedPackage();
         if (!$pname) {
             return;
+        }
         $deps = $this->getDeps();
         if (!$deps) {
             return;
+        }
         if (isset($deps['required'])) { // package.xml 2.0
-            return $this->_detect2($deps, $pname, $options, $params);
-        } else {
-            return $this->_detect1($deps, $pname, $options, $params);
+            return $this->_detect2($deps, $pname, $options, $params);
+        }
         return $this->_detect1($deps, $pname, $options, $params);
+    }
     function setValidated()
+    }
     /**
      * Remove packages to be downloaded that are already installed
-     * @param array of PEAR_Downloader_Package objects
-     * @static
+     * @param array of PEAR_Downloader_Package objects
      */
-    function removeInstalled(&$params)
+    public static function removeInstalled(&$params)
+    {
         if (!isset($params[0])) {
             return;
+        }
         $options = $params[0]->_downloader->getOptions();
         if (!isset($options['downloadonly'])) {
+            foreach ($params as $i => $param) {
+                $package = $param->getPackage();
-            foreach ($params as $i => $param) {
+                $channel = $param->getChannel();
                 // remove self if already installed with this version
                 // this does not need any pecl magic - we only remove exact matches
-                if ($param->_installRegistry->packageExists($param->getPackage(), $param->getChannel())) {
+                if ($param->_installRegistry->packageExists($package, $channel)) {
-                    if (version_compare($param->_installRegistry->packageInfo($param->getPackage(), 'version',
+                    $packageVersion = $param->_installRegistry->packageInfo($package, 'version', $channel);
-                          $param->getChannel()), $param->getVersion(), '==')) {
+                    if (version_compare($packageVersion, $param->getVersion(), '==')) {
-                        if (!isset($options['force'])) {
+                        if (!isset($options['force']) && !isset($options['packagingroot'])) {
                             $info = $param->getParsedPackage();
                             unset($info['version']);
                             unset($info['state']);
                             if (!isset($options['soft'])) {
                                 $param->_downloader->log(1, 'Skipping package "' .
                                     $param->getShortName() .
-                                    '", already installed as version ' .
-                                    $param->_installRegistry->packageInfo($param->getPackage(),
-                                        'version', $param->getChannel()));
+                                    '", already installed as version ' . $packageVersion);
+                            }
                             $params[$i] = false;
+                        }
                     } elseif (!isset($options['force']) && !isset($options['upgrade']) &&
-                          !isset($options['soft'])) {
+                          !isset($options['soft']) && !isset($options['packagingroot'])) {
                         $info = $param->getParsedPackage();
                         $param->_downloader->log(1, 'Skipping package "' .
                             $param->getShortName() .
-                            '", already installed as version ' .
-                            $param->_installRegistry->packageInfo($param->getPackage(), 'version',
-                                $param->getChannel()));
+                            '", already installed as version ' . $packageVersion);
                         $params[$i] = false;
+                    }
+                }
+            }
+        }
         PEAR_Downloader_Package::removeDuplicates($params);
+    }
                             continue;
+                        }
                         $ret = $this->_detect2Dep($dep, $pname, 'required', $params);
                         if (is_array($ret)) {
                             $this->_downloadDeps[] = $ret;
+                        } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+                            $this->_downloader->log(0, $ret->getMessage());
+                        }
+                    }
                 } else {
                     $dep = $deps['required'][$packagetype];
                     if (!isset($dep['conflicts'])) {
                         // skip any package that this package conflicts with
                         $ret = $this->_detect2Dep($dep, $pname, 'required', $params);
                         if (is_array($ret)) {
                             $this->_downloadDeps[] = $ret;
+                        } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+                            $this->_downloader->log(0, $ret->getMessage());
+                        }
+                    }
+                }
+            }
             // get optional dependency group, if any
             if (isset($deps['optional'][$packagetype])) {
                 $skipnames = array();
                 if (!isset($deps['optional'][$packagetype][0])) {
                     $deps['optional'][$packagetype] = array($deps['optional'][$packagetype]);
+                }
                 foreach ($deps['optional'][$packagetype] as $dep) {
                     $skip = false;
                     if (!isset($options['alldeps'])) {
                         $dep['package'] = $dep['name'];
                         if (!isset($options['soft'])) {
+                        }
                         $skipnames[] = $this->_registry->parsedPackageNameToString($dep, true);
                         $skip = true;
                         unset($dep['package']);
+                    }
-                    if (!($ret = $this->_detect2Dep($dep, $pname, 'optional', $params))) {
+                    $ret = $this->_detect2Dep($dep, $pname, 'optional', $params);
+                    if (PEAR::isError($ret) && !isset($options['soft'])) {
+                        $this->_downloader->log(0, $ret->getMessage());
+                    }
+                    if (!$ret) {
                         $dep['package'] = $dep['name'];
                         $skip = count($skipnames) ?
                             $skipnames[count($skipnames) - 1] : '';
                         if ($skip ==
                               $this->_registry->parsedPackageNameToString($dep, true)) {
                             array_pop($skipnames);
+                        }
+                    }
                     if (!$skip && is_array($ret)) {
                         $this->_downloadDeps[] = $ret;
+                    }
+                }
                 if (count($skipnames)) {
                     if (!isset($options['soft'])) {
                         $this->_downloader->log(1, 'Did not download optional dependencies: ' .
                             implode(', ', $skipnames) .
                             ', use --alldeps to download automatically');
+                    }
+                }
+            }
             // get requested dependency group, if any
             $groupname = $this->getGroup();
-            $explicit = $this->_explicitGroup;
+            $explicit  = $this->_explicitGroup;
             if (!$groupname) {
-                if ($this->canDefault()) {
+                if (!$this->canDefault()) {
-                    $groupname = 'default'; // try the default dependency group
-                } else {
                     continue;
+                }
+                $groupname = 'default'; // try the default dependency group
+            }
             if ($groupnotfound) {
                 continue;
+            }
             if (isset($deps['group'])) {
                 if (isset($deps['group']['attribs'])) {
                     if (strtolower($deps['group']['attribs']['name']) == strtolower($groupname)) {
                         $group = $deps['group'];
                     } elseif ($explicit) {
                         if (!isset($options['soft'])) {
                             $this->_downloader->log(0, 'Warning: package "' .
                                 $this->_registry->parsedPackageNameToString($pname, true) .
                                 '" has no dependency ' . 'group named "' . $groupname . '"');
+                        }
                         $groupnotfound = true;
                         continue;
+                    }
                 } else {
                     $found = false;
                         if (strtolower($group['attribs']['name']) == strtolower($groupname)) {
                             $found = true;
                             break;
+                        }
+                    }
                     if (!$found) {
                         if ($explicit) {
                             if (!isset($options['soft'])) {
                                 $this->_downloader->log(0, 'Warning: package "' .
                                     $this->_registry->parsedPackageNameToString($pname, true) .
                                     '" has no dependency ' . 'group named "' . $groupname . '"');
+                            }
+                        }
                         $groupnotfound = true;
                         continue;
+                    }
+                }
+            }
-            if (isset($group)) {
-                if (isset($group[$packagetype])) {
+            if (isset($group) && isset($group[$packagetype])) {
-                    if (isset($group[$packagetype][0])) {
+                if (isset($group[$packagetype][0])) {
-                        foreach ($group[$packagetype] as $dep) {
+                    foreach ($group[$packagetype] as $dep) {
-                            $ret = $this->_detect2Dep($dep, $pname, 'dependency group "' .
+                        $ret = $this->_detect2Dep($dep, $pname, 'dependency group "' .
-                                $group['attribs']['name'] . '"', $params);
-                            if (is_array($ret)) {
-                                $this->_downloadDeps[] = $ret;
-                            }
-                        }
-                    } else {
-                        $ret = $this->_detect2Dep($group[$packagetype], $pname,
-                            'dependency group "' .
                             $group['attribs']['name'] . '"', $params);
                         if (is_array($ret)) {
                             $this->_downloadDeps[] = $ret;
+                        } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+                            $this->_downloader->log(0, $ret->getMessage());
+                        }
+                    }
+                } else {
+                    $ret = $this->_detect2Dep($group[$packagetype], $pname,
+                        'dependency group "' .
+                        $group['attribs']['name'] . '"', $params);
+                    if (is_array($ret)) {
+                        $this->_downloadDeps[] = $ret;
+                    } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+                        $this->_downloader->log(0, $ret->getMessage());
+                    }
+                }
+            }
+        }
+    }
     function _detect2Dep($dep, $pname, $group, $params)
+    {
         if (isset($dep['conflicts'])) {
             return true;
+        }
         $options = $this->_downloader->getOptions();
         if (isset($dep['uri'])) {
             return array('uri' => $dep['uri'], 'dep' => $dep);;
+        }
         $testdep = $dep;
         $testdep['package'] = $dep['name'];
         if (PEAR_Downloader_Package::willDownload($testdep, $params)) {
             $dep['package'] = $dep['name'];
                     $this->_registry->parsedPackageNameToString($dep, true) .
                     '", will be installed');
+            }
             return false;
+        }
         $options = $this->_downloader->getOptions();
         PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
         if ($this->_explicitState) {
             $pname['state'] = $this->_explicitState;
+        }
-        $url =
-            $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
+        $url = $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
         if (PEAR::isError($url)) {
             PEAR::popErrorHandling();
             return $url;
+        }
         $dep['package'] = $dep['name'];
         $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params, $group == 'optional' &&
             !isset($options['alldeps']), true);
         PEAR::popErrorHandling();
         if (PEAR::isError($ret)) {
             if (!isset($options['soft'])) {
                 $this->_downloader->log(0, $ret->getMessage());
+            }
             return false;
-        } else {
+        }
-            // check to see if a dep is already installed and is the same or newer
+        // check to see if a dep is already installed and is the same or newer
-            if (!isset($dep['min']) && !isset($dep['max']) && !isset($dep['recommended'])) {
+        if (!isset($dep['min']) && !isset($dep['max']) && !isset($dep['recommended'])) {
-                $oper = 'has';
+            $oper = 'has';
-            } else {
+        } else {
-                $oper = 'gt';
+            $oper = 'gt';
-            }
+        }
-            // do not try to move this before getDepPackageDownloadURL
+        // do not try to move this before getDepPackageDownloadURL
-            // we can't determine whether upgrade is necessary until we know what
+        // we can't determine whether upgrade is necessary until we know what
-            // version would be downloaded
+        // version would be downloaded
-            if (!isset($options['force']) && $this->isInstalled($ret, $oper)) {
+        if (!isset($options['force']) && $this->isInstalled($ret, $oper)) {
-                $version = $this->_installRegistry->packageInfo($dep['name'], 'version',
+            $version = $this->_installRegistry->packageInfo($dep['name'], 'version', $dep['channel']);
-                    $dep['channel']);
-                $dep['package'] = $dep['name'];
+            $dep['package'] = $dep['name'];
-                if (!isset($options['soft'])) {
+            if (!isset($options['soft'])) {
-                    $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group .
+                $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group .
-                        ' dependency "' .
+                    ' dependency "' .
-                    $this->_registry->parsedPackageNameToString($dep, true) .
+                $this->_registry->parsedPackageNameToString($dep, true) .
-                        '" version ' . $url['version'] . ', already installed as version ' .
+                    '" version ' . $url['version'] . ', already installed as version ' .
-                        $version);
+                    $version);
-                }
-                return false;
+            }
+            return false;
+        }
         if (isset($dep['nodefault'])) {
             $ret['nodefault'] = true;
+        }
         return $ret;
+    }
     function _detect1($deps, $pname, $options, $params)
+    {
         $this->_downloadDeps = array();
         $skipnames = array();
         foreach ($deps as $dep) {
             $nodownload = false;
-            if ($dep['type'] == 'pkg') {
+            if (isset ($dep['type']) && $dep['type'] === 'pkg') {
                 $dep['channel'] = 'pear.php.net';
                 $dep['package'] = $dep['name'];
                 switch ($dep['rel']) {
                     case 'not' :
                                 $this->_registry->parsedPackageNameToString($dep, true) .
                                 '", is already installed');
                             continue 2;
+                        }
+                }
                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
                 if ($this->_explicitState) {
                     $pname['state'] = $this->_explicitState;
+                }
-                $url =
-                    $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
+                $url = $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
                 $chan = 'pear.php.net';
                 if (PEAR::isError($url)) {
                     // check to see if this is a pecl package that has jumped
                     // from pear.php.net to pecl.php.net channel
                     if (!class_exists('PEAR_Dependency2')) {
                         require_once 'PEAR/Dependency2.php';
+                    }
                     $newdep = PEAR_Dependency2::normalizeDep($dep);
                     $newdep = $newdep[0];
                     $newdep['channel'] = 'pecl.php.net';
                     $chan = 'pecl.php.net';
-                    $url =
-                        $this->_downloader->_getDepPackageDownloadUrl($newdep, $pname);
+                    $url = $this->_downloader->_getDepPackageDownloadUrl($newdep, $pname);
                     $obj = &$this->_installRegistry->getPackage($dep['name']);
                     if (PEAR::isError($url)) {
                         PEAR::popErrorHandling();
                         if ($obj !== null && $this->isInstalled($obj, $dep['rel'])) {
                             $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
+                            }
                             continue;
                         } else {
                             if (isset($dep['optional']) && $dep['optional'] == 'yes') {
                                 $this->_downloader->log(2, $this->getShortName() .
-                                    ': Skipping ' . $group
-                                    . ' dependency "' .
+                                    ': Skipping optional dependency "' .
                                     $this->_registry->parsedPackageNameToString($dep, true) .
                                     '", no releases exist');
                                 continue;
                             } else {
                                 return $url;
+                            }
+                        }
+                    }
+                }
                 PEAR::popErrorHandling();
                 if (!isset($options['alldeps'])) {
                     if (isset($dep['optional']) && $dep['optional'] == 'yes') {
                         if (!isset($options['soft'])) {
                             $this->_downloader->log(3, 'Notice: package "' .
                                 array('channel' => $chan, 'package' =>
                                 $dep['name']), true);
                         $nodownload = true;
+                    }
+                }
                 if (!isset($options['alldeps']) && !isset($options['onlyreqdeps'])) {
                     if (!isset($dep['optional']) || $dep['optional'] == 'no') {
                         if (!isset($options['soft'])) {
                             $this->_downloader->log(3, 'Notice: package "' .
                                 $this->getShortName() .
                                 array('channel' => $chan, 'package' =>
                                 $dep['name']), true);
                         $nodownload = true;
+                    }
+                }
                 // check to see if a dep is already installed
                 // do not try to move this before getDepPackageDownloadURL
                 // we can't determine whether upgrade is necessary until we know what
                 // version would be downloaded
                 if (!isset($options['force']) && $this->isInstalled(
                     $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
                         'required' :
                         'optional';
                     $dep['package'] = $dep['name'];
                     if (isset($newdep)) {
-                        $version = $this->_installRegistry->packageInfo($newdep['name'], 'version',
+                        $version = $this->_installRegistry->packageInfo($newdep['name'], 'version', $newdep['channel']);
-                            $newdep['channel']);
                     } else {
                         $version = $this->_installRegistry->packageInfo($dep['name'], 'version');
+                    }
                     $dep['version'] = $url['version'];
                     if (!isset($options['soft'])) {
                         $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group .
                             ' dependency "' .
                             $this->_registry->parsedPackageNameToString($dep, true) .
                             '", already installed as version ' . $version);
+                    }
                     $skip = count($skipnames) ?
                         $skipnames[count($skipnames) - 1] : '';
                     if ($skip ==
                           $this->_registry->parsedPackageNameToString($dep, true)) {
                         array_pop($skipnames);
+                    }
                     continue;
+                }
                 if ($nodownload) {
                     continue;
+                }
                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
                 if (isset($newdep)) {
                     $dep = $newdep;
+                }
                 $dep['package'] = $dep['name'];
                 $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params,
                     isset($dep['optional']) && $dep['optional'] == 'yes' &&
                     !isset($options['alldeps']), true);
                 PEAR::popErrorHandling();
                     if (!isset($options['soft'])) {
                         $this->_downloader->log(0, $ret->getMessage());
+                    }
                     continue;
+                }
                 $this->_downloadDeps[] = $ret;
+            }
+        }
         if (count($skipnames)) {
             if (!isset($options['soft'])) {
                 $this->_downloader->log(1, 'Did not download dependencies: ' .
                     implode(', ', $skipnames) .
                     ', use --alldeps or --onlyreqdeps to download automatically');
         return $this->_registry->parsedPackageNameToString(array('channel' => $this->getChannel(),
             'package' => $this->getPackage()), true);
+    }
     function getParsedPackage()
+    {
         if (isset($this->_packagefile) || isset($this->_parsedname)) {
             return array('channel' => $this->getChannel(),
                 'package' => $this->getPackage(),
                 'version' => $this->getVersion());
+        }
         return false;
+    }
     function getDownloadURL()
+    {
         return $this->_downloadURL;
+    }
-    function canDefault()
-    {
+    function canDefault()
-        if (isset($this->_downloadURL)) {
             if (isset($this->_downloadURL['nodefault'])) {
+        if (isset($this->_downloadURL) && isset($this->_downloadURL['nodefault'])) {
-                return false;
+            return false;
+        }
         return true;
+    }
     function getPackage()
+    {
-        if (isset($this->_packagefile)) {
-            return $this->_packagefile->getPackage();
-        } elseif (isset($this->_downloadURL['info'])) {
+        if (isset($this->_packagefile)) {
+            return $this->_packagefile->getPackage();
+        } elseif (isset($this->_downloadURL['info'])) {
             return $this->_downloadURL['info']->getPackage();
         } else {
             return false;
         return false;
+    {
         if (isset($this->_packagefile)) {
             return $this->_packagefile->isSubpackage($pf);
         } elseif (isset($this->_downloadURL['info'])) {
             return $this->_downloadURL['info']->isSubpackage($pf);
-        } else {
-            return false;
+        }
+        return false;
+    }
     function getPackageType()
+    {
         if (isset($this->_packagefile)) {
             return $this->_packagefile->getPackageType();
         } elseif (isset($this->_downloadURL['info'])) {
-            return $this->_downloadURL['info']->getPackageType();
-        } else {
-            return false;
+            return $this->_downloadURL['info']->getPackageType();
+        }
         return false;
+    }
     function isBundle()
+    {
-        if (isset($this->_packagefile)) {
-            return $this->_packagefile->getPackageType() == 'bundle';
-        } else {
+        if (isset($this->_packagefile)) {
+            return $this->_packagefile->getPackageType() == 'bundle';
+        }
             return false;
         return false;
+    }
     function getPackageXmlVersion()
+    {
         if (isset($this->_packagefile)) {
-            return $this->_packagefile->getPackagexmlVersion();
-        } elseif (isset($this->_downloadURL['info'])) {
-            return $this->_downloadURL['info']->getPackagexmlVersion();
+            return $this->_packagefile->getPackagexmlVersion();
+        } elseif (isset($this->_downloadURL['info'])) {
+            return $this->_downloadURL['info']->getPackagexmlVersion();
         } else {
             return '1.0';
         return '1.0';
+    }
     function getChannel()
+    {
-        if (isset($this->_packagefile)) {
-            return $this->_packagefile->getChannel();
-        } elseif (isset($this->_downloadURL['info'])) {
+        if (isset($this->_packagefile)) {
+            return $this->_packagefile->getChannel();
+        } elseif (isset($this->_downloadURL['info'])) {
             return $this->_downloadURL['info']->getChannel();
         } else {
             return false;
         return false;
+    }
     function getURI()
-    {
-        if (isset($this->_packagefile)) {
             return $this->_packagefile->getURI();
+        if (isset($this->_packagefile)) {
+            return $this->_packagefile->getURI();
         } elseif (isset($this->_downloadURL['info'])) {
             return $this->_downloadURL['info']->getURI();
         } else {
             return false;
         return false;
+    }
-    function getVersion()
-    {
-        if (isset($this->_packagefile)) {
+    function getVersion()
+    {
+        if (isset($this->_packagefile)) {
             return $this->_packagefile->getVersion();
         } elseif (isset($this->_downloadURL['version'])) {
             return $this->_downloadURL['version'];
         } else {
             return false;
         return false;
+    }
-    function isCompatible($pf)
+    function isCompatible($pf)
+    {
         if (isset($this->_packagefile)) {
             return $this->_packagefile->isCompatible($pf);
         } elseif (isset($this->_downloadURL['info'])) {
             return $this->_downloadURL['info']->isCompatible($pf);
     function getGroup()
+    {
         if (isset($this->_parsedname['group'])) {
-            return $this->_parsedname['group'];
-        } else {
-            return '';
+            return $this->_parsedname['group'];
+        }
         return '';
+    }
     function isExtension($name)
+    {
         if (isset($this->_packagefile)) {
             return $this->_packagefile->isExtension($name);
         } elseif (isset($this->_downloadURL['info'])) {
-			if ($this->_downloadURL['info']->getPackagexmlVersion() == '2.0') {
+            if ($this->_downloadURL['info']->getPackagexmlVersion() == '2.0') {
-				return $this->_downloadURL['info']->getProvidesExtension() == $name;
-			} else {
+                return $this->_downloadURL['info']->getProvidesExtension() == $name;
-				return false;
+            }
         } else {
+            return false;
+        }
             return false;
         return false;
+    }
     function getDeps()
+    {
         if (isset($this->_packagefile)) {
-            $ver = $this->_packagefile->getPackagexmlVersion();
-            if (version_compare($ver, '2.0', '>=')) {
-                return $this->_packagefile->getDeps(true);
+            $ver = $this->_packagefile->getPackagexmlVersion();
+            if (version_compare($ver, '2.0', '>=')) {
+                return $this->_packagefile->getDeps(true);
             } else {
                 return $this->_packagefile->getDeps();
             return $this->_packagefile->getDeps();
         } elseif (isset($this->_downloadURL['info'])) {
-            $ver = $this->_downloadURL['info']->getPackagexmlVersion();
-            if (version_compare($ver, '2.0', '>=')) {
-                return $this->_downloadURL['info']->getDeps(true);
+            $ver = $this->_downloadURL['info']->getPackagexmlVersion();
-            } else {
+            if (version_compare($ver, '2.0', '>=')) {
-                return $this->_downloadURL['info']->getDeps();
+                return $this->_downloadURL['info']->getDeps(true);
+            }
+            return $this->_downloadURL['info']->getDeps();
         } else {
             return array();
         return array();
+    }
                 if ($this->getChannel() != '__uri') {
                     return false;
+                }
                 return $param['uri'] == $this->getURI();
+            }
-            $package = isset($param['package']) ? $param['package'] :
+            $package = isset($param['package']) ? $param['package'] : $param['info']->getPackage();
-                $param['info']->getPackage();
-            $channel = isset($param['channel']) ? $param['channel'] :
+            $channel = isset($param['channel']) ? $param['channel'] : $param['info']->getChannel();
-                $param['info']->getChannel();
             if (isset($param['rel'])) {
                 if (!class_exists('PEAR_Dependency2')) {
                     require_once 'PEAR/Dependency2.php';
+                }
                 $newdep = PEAR_Dependency2::normalizeDep($param);
                 $newdep = $newdep[0];
             } elseif (isset($param['min'])) {
                 $newdep = $param;
+            }
+        }
         if (isset($newdep)) {
             if (!isset($newdep['min'])) {
                 $newdep['min'] = '0';
+            }
             if (!isset($newdep['max'])) {
                 $newdep['max'] = '100000000000000000000';
+            }
             // use magic to support pecl packages suddenly jumping to the pecl channel
             // we need to support both dependency possibilities
             if ($channel == 'pear.php.net' && $this->getChannel() == 'pecl.php.net') {
                 if ($package == $this->getPackage()) {
                     $channel = 'pecl.php.net';
             if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') {
                 if ($package == $this->getPackage()) {
                     $channel = 'pear.php.net';
+                }
+            }
             return (strtolower($package) == strtolower($this->getPackage()) &&
                 $channel == $this->getChannel() &&
                 version_compare($newdep['min'], $this->getVersion(), '<=') &&
                 version_compare($newdep['max'], $this->getVersion(), '>='));
+        }
         // use magic to support pecl packages suddenly jumping to the pecl channel
         if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') {
             if (strtolower($package) == strtolower($this->getPackage())) {
                 $channel = 'pear.php.net';
+            }
+        }
         if (isset($param['version'])) {
             return (strtolower($package) == strtolower($this->getPackage()) &&
                 $channel == $this->getChannel() &&
                 $param['version'] == $this->getVersion());
-        } else {
-            return strtolower($package) == strtolower($this->getPackage()) &&
-                $channel == $this->getChannel();
+        }
+        return strtolower($package) == strtolower($this->getPackage()) &&
+            $channel == $this->getChannel();
+    }
     function isInstalled($dep, $oper = '==')
+    {
         if (!$dep) {
             return false;
+        }
         if ($oper != 'ge' && $oper != 'gt' && $oper != 'has' && $oper != '==') {
             return false;
+        }
         if (is_object($dep)) {
             $package = $dep->getPackage();
             $channel = $dep->getChannel();
             if ($dep->getURI()) {
             } else {
                 $channel = $dep['info']->getChannel();
                 $package = $dep['info']->getPackage();
+            }
+        }
         $options = $this->_downloader->getOptions();
-        $test = $this->_installRegistry->packageExists($package, $channel);
+        $test    = $this->_installRegistry->packageExists($package, $channel);
         if (!$test && $channel == 'pecl.php.net') {
             // do magic to allow upgrading from old pecl packages to new ones
             $test = $this->_installRegistry->packageExists($package, 'pear.php.net');
             $channel = 'pear.php.net';
+        }
         if ($test) {
             if (isset($dep['uri'])) {
                 if ($this->_installRegistry->packageInfo($package, 'uri', '__uri') == $dep['uri']) {
                     return true;
+                }
+            }
             if (isset($options['upgrade'])) {
-                if ($oper == 'has') {
-                    if (version_compare($this->_installRegistry->packageInfo(
+                $packageVersion = $this->_installRegistry->packageInfo($package, 'version', $channel);
-                          $package, 'version', $channel),
-                          $dep['version'], '>=')) {
-                        return true;
-                    } else {
-                        return false;
-                    }
-                } else {
-                    if (version_compare($this->_installRegistry->packageInfo(
-                          $package, 'version', $channel),
-                          $dep['version'], '>=')) {
+                if (version_compare($packageVersion, $dep['version'], '>=')) {
-                        return true;
+                    return true;
-                    }
-                    return false;
+                }
+                return false;
+            }
             return true;
+        }
         return false;
+    }
+    /**
+     * Detect duplicate package names with differing versions
+     *
+     * If a user requests to install Date 1.4.6 and Date 1.4.7,
+     * for instance, this is a logic error.  This method
+     * detects this situation.
+     *
+     * @param array $params array of PEAR_Downloader_Package objects
+     * @param array $errorparams empty array
+     * @return array array of stupid duplicated packages in PEAR_Downloader_Package obejcts
+     */
+    public static function detectStupidDuplicates($params, &$errorparams)
+    {
+        $existing = array();
+        foreach ($params as $i => $param) {
+            $package = $param->getPackage();
+            $channel = $param->getChannel();
+            $group   = $param->getGroup();
+            if (!isset($existing[$channel . '/' . $package])) {
+                $existing[$channel . '/' . $package] = array();
+            }
+            if (!isset($existing[$channel . '/' . $package][$group])) {
+                $existing[$channel . '/' . $package][$group] = array();
+            }
+            $existing[$channel . '/' . $package][$group][] = $i;
+        }
+        $indices = array();
+        foreach ($existing as $package => $groups) {
+            foreach ($groups as $group => $dupes) {
+                if (count($dupes) > 1) {
+                    $indices = $indices + $dupes;
+                }
+            }
+        }
+        $indices = array_unique($indices);
+        foreach ($indices as $index) {
+            $errorparams[] = $params[$index];
+        }
+        return count($errorparams);
+    }
     /**
      * @param array
-     * @param bool ignore install groups - for final removal of dupe packages
-     * @static
+     * @param bool ignore install groups - for final removal of dupe packages
      */
-    function removeDuplicates(&$params, $ignoreGroups = false)
+    public static function removeDuplicates(&$params, $ignoreGroups = false)
+    {
         $pnames = array();
         foreach ($params as $i => $param) {
             if (!$param) {
                 continue;
+            }
-            if ($param->getPackage()) {
-                if ($ignoreGroups) {
-                    $group = '';
-                } else {
+            if ($param->getPackage()) {
-                    $group = $param->getGroup();
                 $group = $ignoreGroups ? '' : $param->getGroup();
                 $pnames[$i] = $param->getChannel() . '/' .
                     $param->getPackage() . '-' . $param->getVersion() . '#' . $group;
+            }
+        }
         $pnames = array_unique($pnames);
-        $unset = array_diff(array_keys($params), array_keys($pnames));
+        $unset  = array_diff(array_keys($params), array_keys($pnames));
-        $testp = array_flip($pnames);
+        $testp  = array_flip($pnames);
         foreach ($params as $i => $param) {
             if (!$param) {
                 $unset[] = $i;
                 continue;
+            }
             if (!is_a($param, 'PEAR_Downloader_Package')) {
                 $unset[] = $i;
                 continue;
-            }
-            if ($ignoreGroups) {
-                $group = '';
+            }
-            } else {
-                $group = $param->getGroup();
             $group = $ignoreGroups ? '' : $param->getGroup();
             if (!isset($testp[$param->getChannel() . '/' . $param->getPackage() . '-' .
                   $param->getVersion() . '#' . $group])) {
                 $unset[] = $i;
+            }
+        }
         foreach ($unset as $i) {
             unset($params[$i]);
+        }
         $ret = array();
         foreach ($params as $i => $param) {
             $ret[] = &$params[$i];
+        }
         $params = array();
         foreach ($ret as $i => $param) {
             $params[] = &$ret[$i];
+        }
+    {
         $this->_explicitState = $s;
+    }
-    /**
-     * @static
+    /**
      */
-    function mergeDependencies(&$params)
+    public static function mergeDependencies(&$params)
     {
-        $newparams = array();
-        $bundles = array();
+        $bundles = $newparams = array();
         foreach ($params as $i => $param) {
             if (!$param->isBundle()) {
                 continue;
+            }
             $bundles[] = $i;
             $pf = &$param->getPackageFile();
             $newdeps = array();
             $contents = $pf->getBundledPackages();
             if (!is_array($contents)) {
                 $contents = array($contents);
+            }
             foreach ($contents as $file) {
                 $filecontents = $pf->getFileContents($file);
                 $dl = &$param->getDownloader();
                 $options = $dl->getOptions();
                 if (PEAR::isError($dir = $dl->getDownloadDir())) {
                     return $dir;
+                }
                 $fp = @fopen($dir . DIRECTORY_SEPARATOR . $file, 'wb');
                 if (!$fp) {
                     continue;
+                }
+                // FIXME do symlink check
                 fwrite($fp, $filecontents, strlen($filecontents));
                 fclose($fp);
                 if ($s = $params[$i]->explicitState()) {
                     $obj->setExplicitState($s);
+                }
-                }
-                $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader());
+                $obj = new PEAR_Downloader_Package($params[$i]->getDownloader());
                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
                 if (PEAR::isError($dir = $dl->getDownloadDir())) {
                     PEAR::popErrorHandling();
                     return $dir;
                 }
+                $a = $dir . DIRECTORY_SEPARATOR . $file;
-                $e = $obj->_fromFile($a = $dir . DIRECTORY_SEPARATOR . $file);
+                $e = $obj->_fromFile($a);
                 PEAR::popErrorHandling();
                 if (PEAR::isError($e)) {
                     if (!isset($options['soft'])) {
                         $dl->log(0, $e->getMessage());
+                    }
                     continue;
-                }
+                }
-                $j = &$obj;
-                if (!PEAR_Downloader_Package::willDownload($j,
+                if (!PEAR_Downloader_Package::willDownload($obj,
-                      array_merge($params, $newparams)) && !$param->isInstalled($j)) {
+                      array_merge($params, $newparams)) && !$param->isInstalled($obj)) {
-                    $newparams[] = &$j;
+                    $newparams[] = $obj;
+                }
+            }
+        }
         foreach ($bundles as $i) {
             unset($params[$i]); // remove bundles - only their contents matter for installation
+        }
         PEAR_Downloader_Package::removeDuplicates($params); // strip any unset indices
         if (count($newparams)) { // add in bundled packages for install
             foreach ($newparams as $i => $unused) {
                 $params[] = &$newparams[$i];
+            }
             $newparams = array();
+        }
         foreach ($params as $i => $param) {
             $newdeps = array();
+            foreach ($param->_downloadDeps as $dep) {
-            foreach ($param->_downloadDeps as $dep) {
+                $merge = array_merge($params, $newparams);
-                if (!PEAR_Downloader_Package::willDownload($dep,
+                if (!PEAR_Downloader_Package::willDownload($dep, $merge)
+                    && !$param->isInstalled($dep)
-                      array_merge($params, $newparams)) && !$param->isInstalled($dep)) {
+                ) {
                     $newdeps[] = $dep;
+                } else {
-                } else {
+                    //var_dump($dep);
                     // detect versioning conflicts here
+                }
+            }
-            }
-            // convert the dependencies into PEAR_Downloader_Package objects for the next time
-            // around
+            // convert the dependencies into PEAR_Downloader_Package objects for the next time around
             $params[$i]->_downloadDeps = array();
             foreach ($newdeps as $dep) {
-                $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader());
+                $obj = new PEAR_Downloader_Package($params[$i]->getDownloader());
                 if ($s = $params[$i]->explicitState()) {
                     $obj->setExplicitState($s);
+                }
                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
                 $e = $obj->fromDepURL($dep);
                 PEAR::popErrorHandling();
                 if (PEAR::isError($e)) {
                     if (!isset($options['soft'])) {
                         $obj->_downloader->log(0, $e->getMessage());
+                    }
                     continue;
+                }
                 $e = $obj->detectDependencies($params);
                 if (PEAR::isError($e)) {
                     if (!isset($options['soft'])) {
                         $obj->_downloader->log(0, $e->getMessage());
+                    }
-                }
+                }
-                $j = &$obj;
-                $newparams[] = &$j;
+                $newparams[] = $obj;
+            }
+        }
         if (count($newparams)) {
             foreach ($newparams as $i => $unused) {
                 $params[] = &$newparams[$i];
+            }
-            return true;
-        } else {
-            return false;
+            return true;
+        }
         return false;
+    }
-    /**
-     * @static
+    /**
      */
-    function willDownload($param, $params)
+    public static function willDownload($param, $params)
+    {
+        if (!is_array($params)) {
-        if (!is_array($params)) {
+            return false;
             return false;
         foreach ($params as $obj) {
             if ($obj->isEqual($param)) {
+                return true;
                 return true;
+        }
         return false;
+    }
     /**
      * For simpler unit-testing
      * @param PEAR_Config
      * @param int
      * @param string
      */
-    function &getPackagefileObject(&$c, $d, $t = false)
+    function &getPackagefileObject(&$c, $d)
-    {
         $a = &new PEAR_PackageFile($c, $d, $t);
-        return $a;
+        $a = new PEAR_PackageFile($c, $d);
         return $a;
+    }
         $saveparam = $param;
         if (is_string($param)) {
             if (!@file_exists($param)) {
                 $test = explode('#', $param);
                 $group = array_pop($test);
-                if (file_exists(implode('#', $test))) {
+                if (@file_exists(implode('#', $test))) {
                     $this->setGroup($group);
                     $param = implode('#', $test);
                     $this->_explicitGroup = true;
+                }
+            }
             if (@is_file($param)) {
                 $this->_type = 'local';
                 $options = $this->_downloader->getOptions();
-                if (isset($options['downloadonly'])) {
-                    $pkg = &$this->getPackagefileObject($this->_config,
+                $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->_debug);
-                        $this->_downloader->_debug);
-                } else {
-                    if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) {
-                        return $dir;
-                    }
-                    $pkg = &$this->getPackagefileObject($this->_config,
-                        $this->_downloader->_debug, $dir);
-                }
                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
                 $pf = &$pkg->fromAnyFile($param, PEAR_VALIDATE_INSTALLING);
                 PEAR::popErrorHandling();
                 if (PEAR::isError($pf)) {
                     $this->_valid = false;
         return $this->_valid = false;
+    }
     function _fromUrl($param, $saveparam = '')
-    {
-        if (!is_array($param) &&
+    {
-              (preg_match('#^(http|ftp)://#', $param))) {
+        if (!is_array($param) && (preg_match('#^(http|https|ftp)://#', $param))) {
             $options = $this->_downloader->getOptions();
             $this->_type = 'url';
             $callback = $this->_downloader->ui ?
                 array(&$this->_downloader, '_downloadCallback') : null;
             $this->_downloader->pushErrorHandling(PEAR_ERROR_RETURN);
             if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) {
                 $this->_downloader->popErrorHandling();
                 return $dir;
+            }
             $this->_downloader->log(3, 'Downloading "' . $param . '"');
             $file = $this->_downloader->downloadHttp($param, $this->_downloader->ui,
-                $dir, $callback);
+                $dir, $callback, null, false, $this->getChannel());
             $this->_downloader->popErrorHandling();
             if (PEAR::isError($file)) {
                 if (!empty($saveparam)) {
                     $saveparam = ", cannot download \"$saveparam\"";
+                }
                 $err = PEAR::raiseError('Could not download from "' . $param .
                     '"' . $saveparam . ' (' . $file->getMessage() . ')');
                     return $err;
+            }
             if ($this->_rawpackagefile) {
                 require_once 'Archive/Tar.php';
-                $tar = &new Archive_Tar($file);
+                $tar = new Archive_Tar($file);
                 $packagexml = $tar->extractInString('package2.xml');
                 if (!$packagexml) {
                     $packagexml = $tar->extractInString('package.xml');
+                }
                 if (str_replace(array("\n", "\r"), array('',''), $packagexml) !=
                       str_replace(array("\n", "\r"), array('',''), $this->_rawpackagefile)) {
-                    if ($this->getChannel() == 'pear.php.net') {
-                        // be more lax for the existing PEAR packages that have not-ok
-                        // characters in their package.xml
-                        $this->_downloader->log(0, 'CRITICAL WARNING: The "' .
-                            $this->getPackage() . '" package has invalid characters in its ' .
-                            'package.xml.  The next version of PEAR may not be able to install ' .
-                            'this package for security reasons.  Please open a bug report at ' .
-                            'http://pear.php.net/package/' . $this->getPackage() . '/bugs');
-                    } else {
+                    if ($this->getChannel() != 'pear.php.net') {
                         return PEAR::raiseError('CRITICAL ERROR: package.xml downloaded does ' .
                             'not match value returned from xml-rpc');
+                    }
+                    // be more lax for the existing PEAR packages that have not-ok
+                    // characters in their package.xml
+                    $this->_downloader->log(0, 'CRITICAL WARNING: The "' .
+                        $this->getPackage() . '" package has invalid characters in its ' .
+                        'package.xml.  The next version of PEAR may not be able to install ' .
+                        'this package for security reasons.  Please open a bug report at ' .
                         'http://pear.php.net/package/' . $this->getPackage() . '/bugs');
+                }
+            }
-            // whew, download worked!
-            if (isset($options['downloadonly'])) {
+            // whew, download worked!
-                $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug);
-            } else {
-                if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) {
-                    return $dir;
-                }
-                $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug,
-                    $dir);
+            $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug);
             PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
             $pf = &$pkg->fromAnyFile($file, PEAR_VALIDATE_INSTALLING);
             PEAR::popErrorHandling();
             if (PEAR::isError($pf)) {
                 if (is_array($pf->getUserInfo())) {
                     foreach ($pf->getUserInfo() as $err) {
                         if (is_array($err)) {
                             $err = $err['message'];
+                        }
                         if (!isset($options['soft'])) {
                             $this->_downloader->log(0, "Validation Error: $err");
+                        }
+                    }
+                }
                 if (!isset($options['soft'])) {
                     $this->_downloader->log(0, $pf->getMessage());
+                }
+                ///FIXME need to pass back some error code that we can use to match with to cancel all further operations
-                }
+                /// At least stop all deps of this package from being installed
-                $err = PEAR::raiseError('Download of "' . ($saveparam ? $saveparam :
+                $out = $saveparam ? $saveparam : $param;
-                    $param) . '" succeeded, but it is not a valid package archive');
+                $err = PEAR::raiseError('Download of "' . $out . '" succeeded, but it is not a valid package archive');
                 $this->_valid = false;
                 return $err;
+            }
             $this->_packagefile = &$pf;
             $this->setGroup('default'); // install the default dependency group
             return $this->_valid = true;
+        }
         return $this->_valid = false;
+    }
      *                     or a string of format [channame/]pname[-version|-state]
      */
     function _fromString($param)
+    {
         $options = $this->_downloader->getOptions();
+        $channel = $this->_config->get('default_channel');
         PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
-        $pname = $this->_registry->parsePackageName($param,
+        $pname = $this->_registry->parsePackageName($param, $channel);
-            $this->_config->get('default_channel'));
         PEAR::popErrorHandling();
         if (PEAR::isError($pname)) {
             if ($pname->getCode() == 'invalid') {
                 $this->_valid = false;
                 return false;
+            }
             if ($pname->getCode() == 'channel') {
                 $parsed = $pname->getUserInfo();
                 if ($this->_downloader->discover($parsed['channel'])) {
                     if ($this->_config->get('auto_discover')) {
                         PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
-                        $pname = $this->_registry->parsePackageName($param,
+                        $pname = $this->_registry->parsePackageName($param, $channel);
-                            $this->_config->get('default_channel'));
                         PEAR::popErrorHandling();
                     } else {
                         if (!isset($options['soft'])) {
                             $this->_downloader->log(0, 'Channel "' . $parsed['channel'] .
                                 '" is not initialized, use ' .
                                 '"pear channel-discover ' . $parsed['channel'] . '" to initialize' .
                                 'or pear config-set auto_discover 1');
+                        }
+                    }
+                }
                 if (PEAR::isError($pname)) {
                     if (!isset($options['soft'])) {
                         $this->_downloader->log(0, $pname->getMessage());
+                    }
                     if (is_array($param)) {
                         $param = $this->_registry->parsedPackageNameToString($param);
+                    }
-                    $err = PEAR::raiseError('invalid package name/package file "' .
+                    $err = PEAR::raiseError('invalid package name/package file "' . $param . '"');
-                        $param . '"');
                     $this->_valid = false;
                     return $err;
+                }
             } else {
                 if (!isset($options['soft'])) {
                     $this->_downloader->log(0, $pname->getMessage());
+                }
-                $err = PEAR::raiseError('invalid package name/package file "' .
+                $err = PEAR::raiseError('invalid package name/package file "' . $param . '"');
-                    $param . '"');
                 $this->_valid = false;
                 return $err;
+            }
+        }
         if (!isset($this->_type)) {
-            $this->_type = 'xmlrpc';
+            $this->_type = 'rest';
-        }
-        $this->_parsedname = $pname;
-        if (isset($pname['state'])) {
-            $this->_explicitState = $pname['state'];
-        } else {
-            $this->_explicitState = false;
-        }
-        if (isset($pname['group'])) {
-            $this->_explicitGroup = true;
-        } else {
-            $this->_explicitGroup = false;
+        }
+        $this->_parsedname    = $pname;
+        $this->_explicitState = isset($pname['state']) ? $pname['state'] : false;
+        $this->_explicitGroup = isset($pname['group']) ? true : false;
         $info = $this->_downloader->_getPackageDownloadUrl($pname);
         if (PEAR::isError($info)) {
             if ($info->getCode() != -976 && $pname['channel'] == 'pear.php.net') {
                 // try pecl
                 $pname['channel'] = 'pecl.php.net';
+                    }
                 } else {
                     $pname['channel'] = 'pear.php.net';
+                }
+            }
             return $info;
+        }
         $this->_rawpackagefile = $info['raw'];
         $ret = $this->_analyzeDownloadURL($info, $param, $pname);
         if (PEAR::isError($ret)) {
             return $ret;
+        }
         if ($ret) {
             $this->_downloadURL = $ret;
             return $this->_valid = (bool) $ret;
+        }
+    }
                                  $isdependency = false)
+    {
         if (!is_string($param) && PEAR_Downloader_Package::willDownload($param, $params)) {
             return false;
+        }
-        if (!$info) {
+        if ($info === false) {
-            if (!is_string($param)) {
-                $saveparam = ", cannot download \"$param\"";
+            $saveparam = !is_string($param) ? ", cannot download \"$param\"" : '';
-            } else {
-                $saveparam = '';
-            }
             // no releases exist
             return PEAR::raiseError('No releases for package "' .
                 $this->_registry->parsedPackageNameToString($pname, true) . '" exist' . $saveparam);
+        }
         if (strtolower($info['info']->getChannel()) != strtolower($pname['channel'])) {
             $err = false;
             if ($pname['channel'] == 'pecl.php.net') {
                 if ($info['info']->getChannel() != 'pear.php.net') {
                     $err = true;
                     $err = true;
+                }
             } else {
                 $err = true;
+            }
             if ($err) {
                 return PEAR::raiseError('SECURITY ERROR: package in channel "' . $pname['channel'] .
                     '" retrieved another channel\'s name for download! ("' .
                     $info['info']->getChannel() . '")');
+            }
+        }
+        $preferred_state = $this->_config->get('preferred_state');
         if (!isset($info['url'])) {
+            $package_version = $this->_registry->packageInfo($info['info']->getPackage(),
+            'version', $info['info']->getChannel());
             if ($this->isInstalled($info)) {
-                if ($isdependency && version_compare($info['version'],
+                if ($isdependency && version_compare($info['version'], $package_version, '<=')) {
-                      $this->_registry->packageInfo($info['info']->getPackage(),
-                            'version', $info['info']->getChannel()), '<=')) {
                     // ignore bogus errors of "failed to download dependency"
                     // if it is already installed and the one that would be
                     // downloaded is older or the same version (Bug #7219)
                     return false;
+                }
+            }
+            if ($info['version'] === $package_version) {
+                if (!isset($options['soft'])) {
+                    $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
+                        '/' . $pname['package'] . '-' . $package_version. ', additionally the suggested version' .
+                        ' (' . $package_version . ') is the same as the locally installed one.');
+                }
+                return false;
+            }
+            if (version_compare($info['version'], $package_version, '<=')) {
+                if (!isset($options['soft'])) {
+                    $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
+                        '/' . $pname['package'] . '-' . $package_version . ', additionally the suggested version' .
+                        ' (' . $info['version'] . ') is a lower version than the locally installed one (' . $package_version . ').');
+                }
+                return false;
+            }
             $instead =  ', will instead download version ' . $info['version'] .
                         ', stability "' . $info['info']->getState() . '"';
             // releases exist, but we failed to get any
             if (isset($this->_downloader->_options['force'])) {
                 if (isset($pname['version'])) {
                     $vs = ', stability "' . $pname['state'] . '"';
                 } elseif ($param == 'dependency') {
                     if (!class_exists('PEAR_Common')) {
                         require_once 'PEAR/Common.php';
+                    }
                     if (!in_array($info['info']->getState(),
-                          PEAR_Common::betterStates($this->_config->get('preferred_state'), true))) {
+                          PEAR_Common::betterStates($preferred_state, true))) {
                         if ($optional) {
                             // don't spit out confusing error message
                             return $this->_downloader->_getPackageDownloadUrl(
                                 array('package' => $pname['package'],
                                       'channel' => $pname['channel'],
                                       'version' => $info['version']));
+                        }
-                        $vs = ' within preferred state "' . $this->_config->get('preferred_state') .
+                        $vs = ' within preferred state "' . $preferred_state .
                             '"';
                     } else {
                         if (!class_exists('PEAR_Dependency2')) {
                             require_once 'PEAR/Dependency2.php';
+                        }
                         if ($optional) {
                             // don't spit out confusing error message
                             return $this->_downloader->_getPackageDownloadUrl(
                                 array('package' => $pname['package'],
                                       'channel' => $pname['channel'],
+                        }
                         $vs = PEAR_Dependency2::_getExtraString($pname);
                         $instead = '';
+                    }
                 } else {
-                    $vs = ' within preferred state "' . $this->_config->get(
+                    $vs = ' within preferred state "' . $preferred_state . '"';
-                        'preferred_state') . '"';
+                }
                 if (!isset($options['soft'])) {
                     $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
                         '/' . $pname['package'] . $vs . $instead);
+                }
                 // download the latest release
                 return $this->_downloader->_getPackageDownloadUrl(
                     array('package' => $pname['package'],
                           'channel' => $pname['channel'],
                           'version' => $info['version']));
             } else {
+                if (isset($info['php']) && $info['php']) {
+                    $err = PEAR::raiseError('Failed to download ' .
+                        $this->_registry->parsedPackageNameToString(
+                            array('channel' => $pname['channel'],
+                                  'package' => $pname['package']),
+                                true) .
+                        ', latest release is version ' . $info['php']['v'] .
+                        ', but it requires PHP version "' .
+                        $info['php']['m'] . '", use "' .
+                        $this->_registry->parsedPackageNameToString(
+                            array('channel' => $pname['channel'], 'package' => $pname['package'],
+                            'version' => $info['php']['v'])) . '" to install',
+                            PEAR_DOWNLOADER_PACKAGE_PHPVERSION);
+                    return $err;
+                }
                 // construct helpful error message
                 if (isset($pname['version'])) {
                     $vs = ', version "' . $pname['version'] . '"';
                 } elseif (isset($pname['state'])) {
                     $vs = ', stability "' . $pname['state'] . '"';
                 } elseif ($param == 'dependency') {
                     if (!class_exists('PEAR_Common')) {
                         require_once 'PEAR/Common.php';
+                    }
                     if (!in_array($info['info']->getState(),
-                          PEAR_Common::betterStates($this->_config->get('preferred_state'), true))) {
+                          PEAR_Common::betterStates($preferred_state, true))) {
                         if ($optional) {
                             // don't spit out confusing error message, and don't die on
                             // optional dep failure!
                             return $this->_downloader->_getPackageDownloadUrl(
                                 array('package' => $pname['package'],
                                       'channel' => $pname['channel'],
                                       'version' => $info['version']));
+                        }
-                        $vs = ' within preferred state "' . $this->_config->get('preferred_state') .
+                        $vs = ' within preferred state "' . $preferred_state . '"';
-                            '"';
                     } else {
                         if (!class_exists('PEAR_Dependency2')) {
                             require_once 'PEAR/Dependency2.php';
+                        }
                         if ($optional) {
                             // don't spit out confusing error message, and don't die on
                             // optional dep failure!
                             return $this->_downloader->_getPackageDownloadUrl(
                                 array('package' => $pname['package'],
                                       'version' => $info['version']));
+                        }
                         $vs = PEAR_Dependency2::_getExtraString($pname);
+                    }
                 } else {
-                    $vs = ' within preferred state "' . $this->_downloader->config->get(
+                    $vs = ' within preferred state "' . $this->_downloader->config->get('preferred_state') . '"';
-                        'preferred_state') . '"';
+                }
                 $options = $this->_downloader->getOptions();
                 // this is only set by the "download-all" command
                 if (isset($options['ignorepreferred_state'])) {
                     $err = PEAR::raiseError(
                         'Failed to download ' . $this->_registry->parsedPackageNameToString(
                             array('channel' => $pname['channel'], 'package' => $pname['package'],
                             'version' => $info['version'])) . '" to install',
                             PEAR_DOWNLOADER_PACKAGE_STATE);
                     return $err;
+                }
+                // Checks if the user has a package installed already and checks the release against
+                // the state against the installed package, this allows upgrades for packages
+                // with lower stability than the preferred_state
+                $stability = $this->_registry->packageInfo($pname['package'], 'stability', $pname['channel']);
+                if (!$this->isInstalled($info)
+                    || !in_array($info['info']->getState(), PEAR_Common::betterStates($stability['release'], true))
+                ) {
-                $err = PEAR::raiseError(
+                    $err = PEAR::raiseError(
-                    'Failed to download ' . $this->_registry->parsedPackageNameToString(
+                        'Failed to download ' . $this->_registry->parsedPackageNameToString(
-                        array('channel' => $pname['channel'], 'package' => $pname['package']),
+                            array('channel' => $pname['channel'], 'package' => $pname['package']),
-                            true)
+                                true)
-                     . $vs .
+                         . $vs .
-                    ', latest release is version ' . $info['version'] .
+                        ', latest release is version ' . $info['version'] .
-                    ', stability "' . $info['info']->getState() . '", use "' .
+                        ', stability "' . $info['info']->getState() . '", use "' .
-                    $this->_registry->parsedPackageNameToString(
+                        $this->_registry->parsedPackageNameToString(
-                        array('channel' => $pname['channel'], 'package' => $pname['package'],
+                            array('channel' => $pname['channel'], 'package' => $pname['package'],
-                        'version' => $info['version'])) . '" to install');
+                            'version' => $info['version'])) . '" to install');
-                return $err;
+                    return $err;
+                }
+            }
+        }
         if (isset($info['deprecated']) && $info['deprecated']) {
             $this->_downloader->log(0,
                 'WARNING: "' .
                     $this->_registry->parsedPackageNameToString(
                             array('channel' => $info['info']->getChannel(),
                                   'package' => $info['info']->getPackage()), true) .
                 '" is deprecated in favor of "' .
                     $this->_registry->parsedPackageNameToString($info['deprecated'], true) .
                 '"');
+        }
         return $info;
+    }
+}
-?>

Subversion Repositories Applications.gtt

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