home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / tmp / PEAR-1.7.1 / PEAR / PackageFile / Generator / v1.php next >
Encoding:
PHP Script  |  2008-02-15  |  49.6 KB  |  1,272 lines
  1. <?php
  2. /**
  3.  * package.xml generation class, package.xml version 1.0
  4.  *
  5.  * PHP versions 4 and 5
  6.  *
  7.  * LICENSE: This source file is subject to version 3.0 of the PHP license
  8.  * that is available through the world-wide-web at the following URI:
  9.  * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
  10.  * the PHP License and are unable to obtain it through the web, please
  11.  * send a note to license@php.net so we can mail you a copy immediately.
  12.  *
  13.  * @category   pear
  14.  * @package    PEAR
  15.  * @author     Greg Beaver <cellog@php.net>
  16.  * @copyright  1997-2008 The PHP Group
  17.  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  18.  * @version    CVS: $Id: v1.php,v 1.74 2008/01/03 20:26:37 cellog Exp $
  19.  * @link       http://pear.php.net/package/PEAR
  20.  * @since      File available since Release 1.4.0a1
  21.  */
  22. /**
  23.  * needed for PEAR_VALIDATE_* constants
  24.  */
  25. require_once 'PEAR/Validate.php';
  26. require_once 'System.php';
  27. require_once 'PEAR/PackageFile/v2.php';
  28. /**
  29.  * This class converts a PEAR_PackageFile_v1 object into any output format.
  30.  *
  31.  * Supported output formats include array, XML string, and a PEAR_PackageFile_v2
  32.  * object, for converting package.xml 1.0 into package.xml 2.0 with no sweat.
  33.  * @category   pear
  34.  * @package    PEAR
  35.  * @author     Greg Beaver <cellog@php.net>
  36.  * @copyright  1997-2008 The PHP Group
  37.  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  38.  * @version    Release: 1.7.1
  39.  * @link       http://pear.php.net/package/PEAR
  40.  * @since      Class available since Release 1.4.0a1
  41.  */
  42. class PEAR_PackageFile_Generator_v1
  43. {
  44.     /**
  45.      * @var PEAR_PackageFile_v1
  46.      */
  47.     var $_packagefile;
  48.     function PEAR_PackageFile_Generator_v1(&$packagefile)
  49.     {
  50.         $this->_packagefile = &$packagefile;
  51.     }
  52.  
  53.     function getPackagerVersion()
  54.     {
  55.         return '1.7.1';
  56.     }
  57.  
  58.     /**
  59.      * @param PEAR_Packager
  60.      * @param bool if true, a .tgz is written, otherwise a .tar is written
  61.      * @param string|null directory in which to save the .tgz
  62.      * @return string|PEAR_Error location of package or error object
  63.      */
  64.     function toTgz(&$packager, $compress = true, $where = null)
  65.     {
  66.         require_once 'Archive/Tar.php';
  67.         if ($where === null) {
  68.             if (!($where = System::mktemp(array('-d')))) {
  69.                 return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: mktemp failed');
  70.             }
  71.         } elseif (!@System::mkDir(array('-p', $where))) {
  72.             return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: "' . $where . '" could' .
  73.                 ' not be created');
  74.         }
  75.         if (file_exists($where . DIRECTORY_SEPARATOR . 'package.xml') &&
  76.               !is_file($where . DIRECTORY_SEPARATOR . 'package.xml')) {
  77.             return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: unable to save package.xml as' .
  78.                 ' "' . $where . DIRECTORY_SEPARATOR . 'package.xml"');
  79.         }
  80.         if (!$this->_packagefile->validate(PEAR_VALIDATE_PACKAGING)) {
  81.             return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: invalid package file');
  82.         }
  83.         $pkginfo = $this->_packagefile->getArray();
  84.         $ext = $compress ? '.tgz' : '.tar';
  85.         $pkgver = $pkginfo['package'] . '-' . $pkginfo['version'];
  86.         $dest_package = getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext;
  87.         if (file_exists(getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext) &&
  88.               !is_file(getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext)) {
  89.             return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: cannot create tgz file "' .
  90.                 getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext . '"');
  91.         }
  92.         if ($pkgfile = $this->_packagefile->getPackageFile()) {
  93.             $pkgdir = dirname(realpath($pkgfile));
  94.             $pkgfile = basename($pkgfile);
  95.         } else {
  96.             return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: package file object must ' .
  97.                 'be created from a real file');
  98.         }
  99.         // {{{ Create the package file list
  100.         $filelist = array();
  101.         $i = 0;
  102.  
  103.         foreach ($this->_packagefile->getFilelist() as $fname => $atts) {
  104.             $file = $pkgdir . DIRECTORY_SEPARATOR . $fname;
  105.             if (!file_exists($file)) {
  106.                 return PEAR::raiseError("File does not exist: $fname");
  107.             } else {
  108.                 $filelist[$i++] = $file;
  109.                 if (!isset($atts['md5sum'])) {
  110.                     $this->_packagefile->setFileAttribute($fname, 'md5sum', md5_file($file));
  111.                 }
  112.                 $packager->log(2, "Adding file $fname");
  113.             }
  114.         }
  115.         // }}}
  116.         $packagexml = $this->toPackageFile($where, PEAR_VALIDATE_PACKAGING, 'package.xml', true);
  117.         if ($packagexml) {
  118.             $tar =& new Archive_Tar($dest_package, $compress);
  119.             $tar->setErrorHandling(PEAR_ERROR_RETURN); // XXX Don't print errors
  120.             // ----- Creates with the package.xml file
  121.             $ok = $tar->createModify(array($packagexml), '', $where);
  122.             if (PEAR::isError($ok)) {
  123.                 return $ok;
  124.             } elseif (!$ok) {
  125.                 return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: tarball creation failed');
  126.             }
  127.             // ----- Add the content of the package
  128.             if (!$tar->addModify($filelist, $pkgver, $pkgdir)) {
  129.                 return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: tarball creation failed');
  130.             }
  131.             return $dest_package;
  132.         }
  133.     }
  134.  
  135.     /**
  136.      * @param string|null directory to place the package.xml in, or null for a temporary dir
  137.      * @param int one of the PEAR_VALIDATE_* constants
  138.      * @param string name of the generated file
  139.      * @param bool if true, then no analysis will be performed on role="php" files
  140.      * @return string|PEAR_Error path to the created file on success
  141.      */
  142.     function toPackageFile($where = null, $state = PEAR_VALIDATE_NORMAL, $name = 'package.xml',
  143.                            $nofilechecking = false)
  144.     {
  145.         if (!$this->_packagefile->validate($state, $nofilechecking)) {
  146.             return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: invalid package.xml',
  147.                 null, null, null, $this->_packagefile->getValidationWarnings());
  148.         }
  149.         if ($where === null) {
  150.             if (!($where = System::mktemp(array('-d')))) {
  151.                 return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: mktemp failed');
  152.             }
  153.         } elseif (!@System::mkDir(array('-p', $where))) {
  154.             return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: "' . $where . '" could' .
  155.                 ' not be created');
  156.         }
  157.         $newpkgfile = $where . DIRECTORY_SEPARATOR . $name;
  158.         $np = @fopen($newpkgfile, 'wb');
  159.         if (!$np) {
  160.             return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: unable to save ' .
  161.                "$name as $newpkgfile");
  162.         }
  163.         fwrite($np, $this->toXml($state, true));
  164.         fclose($np);
  165.         return $newpkgfile;
  166.     }
  167.  
  168.     /**
  169.      * fix both XML encoding to be UTF8, and replace standard XML entities < > " & '
  170.      *
  171.      * @param string $string
  172.      * @return string
  173.      * @access private
  174.      */
  175.     function _fixXmlEncoding($string)
  176.     {
  177.         if (version_compare(phpversion(), '5.0.0', 'lt')) {
  178.             $string = utf8_encode($string);
  179.         }
  180.         return strtr($string, array(
  181.                                           '&'  => '&',
  182.                                           '>'  => '>',
  183.                                           '<'  => '<',
  184.                                           '"'  => '"',
  185.                                           '\'' => ''' ));
  186.     }
  187.  
  188.     /**
  189.      * Return an XML document based on the package info (as returned
  190.      * by the PEAR_Common::infoFrom* methods).
  191.      *
  192.      * @return string XML data
  193.      */
  194.     function toXml($state = PEAR_VALIDATE_NORMAL, $nofilevalidation = false)
  195.     {
  196.         $this->_packagefile->setDate(date('Y-m-d'));
  197.         if (!$this->_packagefile->validate($state, $nofilevalidation)) {
  198.             return false;
  199.         }
  200.         $pkginfo = $this->_packagefile->getArray();
  201.         static $maint_map = array(
  202.             "handle" => "user",
  203.             "name" => "name",
  204.             "email" => "email",
  205.             "role" => "role",
  206.             );
  207.         $ret = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n";
  208.         $ret .= "<!DOCTYPE package SYSTEM \"http://pear.php.net/dtd/package-1.0\">\n";
  209.         $ret .= "<package version=\"1.0\" packagerversion=\"1.7.1\">\n" .
  210. " <name>$pkginfo[package]</name>";
  211.         if (isset($pkginfo['extends'])) {
  212.             $ret .= "\n<extends>$pkginfo[extends]</extends>";
  213.         }
  214.         $ret .=
  215.  "\n <summary>".$this->_fixXmlEncoding($pkginfo['summary'])."</summary>\n" .
  216. " <description>".trim($this->_fixXmlEncoding($pkginfo['description']))."\n </description>\n" .
  217. " <maintainers>\n";
  218.         foreach ($pkginfo['maintainers'] as $maint) {
  219.             $ret .= "  <maintainer>\n";
  220.             foreach ($maint_map as $idx => $elm) {
  221.                 $ret .= "   <$elm>";
  222.                 $ret .= $this->_fixXmlEncoding($maint[$idx]);
  223.                 $ret .= "</$elm>\n";
  224.             }
  225.             $ret .= "  </maintainer>\n";
  226.         }
  227.         $ret .= "  </maintainers>\n";
  228.         $ret .= $this->_makeReleaseXml($pkginfo, false, $state);
  229.         if (isset($pkginfo['changelog']) && count($pkginfo['changelog']) > 0) {
  230.             $ret .= " <changelog>\n";
  231.             foreach ($pkginfo['changelog'] as $oldrelease) {
  232.                 $ret .= $this->_makeReleaseXml($oldrelease, true);
  233.             }
  234.             $ret .= " </changelog>\n";
  235.         }
  236.         $ret .= "</package>\n";
  237.         return $ret;
  238.     }
  239.  
  240.     // }}}
  241.     // {{{ _makeReleaseXml()
  242.  
  243.     /**
  244.      * Generate part of an XML description with release information.
  245.      *
  246.      * @param array  $pkginfo    array with release information
  247.      * @param bool   $changelog  whether the result will be in a changelog element
  248.      *
  249.      * @return string XML data
  250.      *
  251.      * @access private
  252.      */
  253.     function _makeReleaseXml($pkginfo, $changelog = false, $state = PEAR_VALIDATE_NORMAL)
  254.     {
  255.         // XXX QUOTE ENTITIES IN PCDATA, OR EMBED IN CDATA BLOCKS!!
  256.         $indent = $changelog ? "  " : "";
  257.         $ret = "$indent <release>\n";
  258.         if (!empty($pkginfo['version'])) {
  259.             $ret .= "$indent  <version>$pkginfo[version]</version>\n";
  260.         }
  261.         if (!empty($pkginfo['release_date'])) {
  262.             $ret .= "$indent  <date>$pkginfo[release_date]</date>\n";
  263.         }
  264.         if (!empty($pkginfo['release_license'])) {
  265.             $ret .= "$indent  <license>$pkginfo[release_license]</license>\n";
  266.         }
  267.         if (!empty($pkginfo['release_state'])) {
  268.             $ret .= "$indent  <state>$pkginfo[release_state]</state>\n";
  269.         }
  270.         if (!empty($pkginfo['release_notes'])) {
  271.             $ret .= "$indent  <notes>".trim($this->_fixXmlEncoding($pkginfo['release_notes']))
  272.             ."\n$indent  </notes>\n";
  273.         }
  274.         if (!empty($pkginfo['release_warnings'])) {
  275.             $ret .= "$indent  <warnings>".$this->_fixXmlEncoding($pkginfo['release_warnings'])."</warnings>\n";
  276.         }
  277.         if (isset($pkginfo['release_deps']) && sizeof($pkginfo['release_deps']) > 0) {
  278.             $ret .= "$indent  <deps>\n";
  279.             foreach ($pkginfo['release_deps'] as $dep) {
  280.                 $ret .= "$indent   <dep type=\"$dep[type]\" rel=\"$dep[rel]\"";
  281.                 if (isset($dep['version'])) {
  282.                     $ret .= " version=\"$dep[version]\"";
  283.                 }
  284.                 if (isset($dep['optional'])) {
  285.                     $ret .= " optional=\"$dep[optional]\"";
  286.                 }
  287.                 if (isset($dep['name'])) {
  288.                     $ret .= ">$dep[name]</dep>\n";
  289.                 } else {
  290.                     $ret .= "/>\n";
  291.                 }
  292.             }
  293.             $ret .= "$indent  </deps>\n";
  294.         }
  295.         if (isset($pkginfo['configure_options'])) {
  296.             $ret .= "$indent  <configureoptions>\n";
  297.             foreach ($pkginfo['configure_options'] as $c) {
  298.                 $ret .= "$indent   <configureoption name=\"".
  299.                     $this->_fixXmlEncoding($c['name']) . "\"";
  300.                 if (isset($c['default'])) {
  301.                     $ret .= " default=\"" . $this->_fixXmlEncoding($c['default']) . "\"";
  302.                 }
  303.                 $ret .= " prompt=\"" . $this->_fixXmlEncoding($c['prompt']) . "\"";
  304.                 $ret .= "/>\n";
  305.             }
  306.             $ret .= "$indent  </configureoptions>\n";
  307.         }
  308.         if (isset($pkginfo['provides'])) {
  309.             foreach ($pkginfo['provides'] as $key => $what) {
  310.                 $ret .= "$indent  <provides type=\"$what[type]\" ";
  311.                 $ret .= "name=\"$what[name]\" ";
  312.                 if (isset($what['extends'])) {
  313.                     $ret .= "extends=\"$what[extends]\" ";
  314.                 }
  315.                 $ret .= "/>\n";
  316.             }
  317.         }
  318.         if (isset($pkginfo['filelist'])) {
  319.             $ret .= "$indent  <filelist>\n";
  320.             if ($state ^ PEAR_VALIDATE_PACKAGING) {
  321.                 $ret .= $this->recursiveXmlFilelist($pkginfo['filelist']);
  322.             } else {
  323.                 foreach ($pkginfo['filelist'] as $file => $fa) {
  324.                     if (!isset($fa['role'])) {
  325.                         $fa['role'] = '';
  326.                     }
  327.                     $ret .= "$indent   <file role=\"$fa[role]\"";
  328.                     if (isset($fa['baseinstalldir'])) {
  329.                         $ret .= ' baseinstalldir="' .
  330.                             $this->_fixXmlEncoding($fa['baseinstalldir']) . '"';
  331.                     }
  332.                     if (isset($fa['md5sum'])) {
  333.                         $ret .= " md5sum=\"$fa[md5sum]\"";
  334.                     }
  335.                     if (isset($fa['platform'])) {
  336.                         $ret .= " platform=\"$fa[platform]\"";
  337.                     }
  338.                     if (!empty($fa['install-as'])) {
  339.                         $ret .= ' install-as="' .
  340.                             $this->_fixXmlEncoding($fa['install-as']) . '"';
  341.                     }
  342.                     $ret .= ' name="' . $this->_fixXmlEncoding($file) . '"';
  343.                     if (empty($fa['replacements'])) {
  344.                         $ret .= "/>\n";
  345.                     } else {
  346.                         $ret .= ">\n";
  347.                         foreach ($fa['replacements'] as $r) {
  348.                             $ret .= "$indent    <replace";
  349.                             foreach ($r as $k => $v) {
  350.                                 $ret .= " $k=\"" . $this->_fixXmlEncoding($v) .'"';
  351.                             }
  352.                             $ret .= "/>\n";
  353.                         }
  354.                         $ret .= "$indent   </file>\n";
  355.                     }
  356.                 }
  357.             }
  358.             $ret .= "$indent  </filelist>\n";
  359.         }
  360.         $ret .= "$indent </release>\n";
  361.         return $ret;
  362.     }
  363.  
  364.     /**
  365.      * @param array
  366.      * @access protected
  367.      */
  368.     function recursiveXmlFilelist($list)
  369.     {
  370.         $this->_dirs = array();
  371.         foreach ($list as $file => $attributes) {
  372.             $this->_addDir($this->_dirs, explode('/', dirname($file)), $file, $attributes);
  373.         }
  374.         return $this->_formatDir($this->_dirs);
  375.     }
  376.  
  377.     /**
  378.      * @param array
  379.      * @param array
  380.      * @param string|null
  381.      * @param array|null
  382.      * @access private
  383.      */
  384.     function _addDir(&$dirs, $dir, $file = null, $attributes = null)
  385.     {
  386.         if ($dir == array() || $dir == array('.')) {
  387.             $dirs['files'][basename($file)] = $attributes;
  388.             return;
  389.         }
  390.         $curdir = array_shift($dir);
  391.         if (!isset($dirs['dirs'][$curdir])) {
  392.             $dirs['dirs'][$curdir] = array();
  393.         }
  394.         $this->_addDir($dirs['dirs'][$curdir], $dir, $file, $attributes);
  395.     }
  396.  
  397.     /**
  398.      * @param array
  399.      * @param string
  400.      * @param string
  401.      * @access private
  402.      */
  403.     function _formatDir($dirs, $indent = '', $curdir = '')
  404.     {
  405.         $ret = '';
  406.         if (!count($dirs)) {
  407.             return '';
  408.         }
  409.         if (isset($dirs['dirs'])) {
  410.             uksort($dirs['dirs'], 'strnatcasecmp');
  411.             foreach ($dirs['dirs'] as $dir => $contents) {
  412.                 $usedir = "$curdir/$dir";
  413.                 $ret .= "$indent   <dir name=\"$dir\">\n";
  414.                 $ret .= $this->_formatDir($contents, "$indent ", $usedir);
  415.                 $ret .= "$indent   </dir> <!-- $usedir -->\n";
  416.             }
  417.         }
  418.         if (isset($dirs['files'])) {
  419.             uksort($dirs['files'], 'strnatcasecmp');
  420.             foreach ($dirs['files'] as $file => $attribs) {
  421.                 $ret .= $this->_formatFile($file, $attribs, $indent);
  422.             }
  423.         }
  424.         return $ret;
  425.     }
  426.  
  427.     /**
  428.      * @param string
  429.      * @param array
  430.      * @param string
  431.      * @access private
  432.      */
  433.     function _formatFile($file, $attributes, $indent)
  434.     {
  435.         $ret = "$indent   <file role=\"$attributes[role]\"";
  436.         if (isset($attributes['baseinstalldir'])) {
  437.             $ret .= ' baseinstalldir="' .
  438.                 $this->_fixXmlEncoding($attributes['baseinstalldir']) . '"';
  439.         }
  440.         if (isset($attributes['md5sum'])) {
  441.             $ret .= " md5sum=\"$attributes[md5sum]\"";
  442.         }
  443.         if (isset($attributes['platform'])) {
  444.             $ret .= " platform=\"$attributes[platform]\"";
  445.         }
  446.         if (!empty($attributes['install-as'])) {
  447.             $ret .= ' install-as="' .
  448.                 $this->_fixXmlEncoding($attributes['install-as']) . '"';
  449.         }
  450.         $ret .= ' name="' . $this->_fixXmlEncoding($file) . '"';
  451.         if (empty($attributes['replacements'])) {
  452.             $ret .= "/>\n";
  453.         } else {
  454.             $ret .= ">\n";
  455.             foreach ($attributes['replacements'] as $r) {
  456.                 $ret .= "$indent    <replace";
  457.                 foreach ($r as $k => $v) {
  458.                     $ret .= " $k=\"" . $this->_fixXmlEncoding($v) .'"';
  459.                 }
  460.                 $ret .= "/>\n";
  461.             }
  462.             $ret .= "$indent   </file>\n";
  463.         }
  464.         return $ret;
  465.     }
  466.  
  467.     // {{{ _unIndent()
  468.  
  469.     /**
  470.      * Unindent given string (?)
  471.      *
  472.      * @param string $str The string that has to be unindented.
  473.      * @return string
  474.      * @access private
  475.      */
  476.     function _unIndent($str)
  477.     {
  478.         // remove leading newlines
  479.         $str = preg_replace('/^[\r\n]+/', '', $str);
  480.         // find whitespace at the beginning of the first line
  481.         $indent_len = strspn($str, " \t");
  482.         $indent = substr($str, 0, $indent_len);
  483.         $data = '';
  484.         // remove the same amount of whitespace from following lines
  485.         foreach (explode("\n", $str) as $line) {
  486.             if (substr($line, 0, $indent_len) == $indent) {
  487.                 $data .= substr($line, $indent_len) . "\n";
  488.             }
  489.         }
  490.         return $data;
  491.     }
  492.  
  493.     /**
  494.      * @return array
  495.      */
  496.     function dependenciesToV2()
  497.     {
  498.         $arr = array();
  499.         $this->_convertDependencies2_0($arr);
  500.         return $arr['dependencies'];
  501.     }
  502.  
  503.     /**
  504.      * Convert a package.xml version 1.0 into version 2.0
  505.      *
  506.      * Note that this does a basic conversion, to allow more advanced
  507.      * features like bundles and multiple releases
  508.      * @param string the classname to instantiate and return.  This must be
  509.      *               PEAR_PackageFile_v2 or a descendant
  510.      * @param boolean if true, only valid, deterministic package.xml 1.0 as defined by the
  511.      *                strictest parameters will be converted
  512.      * @return PEAR_PackageFile_v2|PEAR_Error
  513.      */
  514.     function &toV2($class = 'PEAR_PackageFile_v2', $strict = false)
  515.     {
  516.         if ($strict) {
  517.             if (!$this->_packagefile->validate()) {
  518.                 $a = PEAR::raiseError('invalid package.xml version 1.0 cannot be converted' .
  519.                     ' to version 2.0', null, null, null,
  520.                     $this->_packagefile->getValidationWarnings(true));
  521.                 return $a;
  522.             }
  523.         }
  524.         $arr = array(
  525.             'attribs' => array(
  526.                              'version' => '2.0',
  527.                              'xmlns' => 'http://pear.php.net/dtd/package-2.0',
  528.                              'xmlns:tasks' => 'http://pear.php.net/dtd/tasks-1.0',
  529.                              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
  530.                              'xsi:schemaLocation' => "http://pear.php.net/dtd/tasks-1.0\n" .
  531. "http://pear.php.net/dtd/tasks-1.0.xsd\n" .
  532. "http://pear.php.net/dtd/package-2.0\n" .
  533. 'http://pear.php.net/dtd/package-2.0.xsd',
  534.                          ),
  535.             'name' => $this->_packagefile->getPackage(),
  536.             'channel' => 'pear.php.net',
  537.         );
  538.         $arr['summary'] = $this->_packagefile->getSummary();
  539.         $arr['description'] = $this->_packagefile->getDescription();
  540.         $maintainers = $this->_packagefile->getMaintainers();
  541.         foreach ($maintainers as $maintainer) {
  542.             if ($maintainer['role'] != 'lead') {
  543.                 continue;
  544.             }
  545.             $new = array(
  546.                 'name' => $maintainer['name'],
  547.                 'user' => $maintainer['handle'],
  548.                 'email' => $maintainer['email'],
  549.                 'active' => 'yes',
  550.             );
  551.             $arr['lead'][] = $new;
  552.         }
  553.         if (!isset($arr['lead'])) { // some people... you know?
  554.             $arr['lead'] = array(
  555.                 'name' => 'unknown',
  556.                 'user' => 'unknown',
  557.                 'email' => 'noleadmaintainer@example.com',
  558.                 'active' => 'no',
  559.             );
  560.         }
  561.         if (count($arr['lead']) == 1) {
  562.             $arr['lead'] = $arr['lead'][0];
  563.         }
  564.         foreach ($maintainers as $maintainer) {
  565.             if ($maintainer['role'] == 'lead') {
  566.                 continue;
  567.             }
  568.             $new = array(
  569.                 'name' => $maintainer['name'],
  570.                 'user' => $maintainer['handle'],
  571.                 'email' => $maintainer['email'],
  572.                 'active' => 'yes',
  573.             );
  574.             $arr[$maintainer['role']][] = $new;
  575.         }
  576.         if (isset($arr['developer']) && count($arr['developer']) == 1) {
  577.             $arr['developer'] = $arr['developer'][0];
  578.         }
  579.         if (isset($arr['contributor']) && count($arr['contributor']) == 1) {
  580.             $arr['contributor'] = $arr['contributor'][0];
  581.         }
  582.         if (isset($arr['helper']) && count($arr['helper']) == 1) {
  583.             $arr['helper'] = $arr['helper'][0];
  584.         }
  585.         $arr['date'] = $this->_packagefile->getDate();
  586.         $arr['version'] =
  587.             array(
  588.                 'release' => $this->_packagefile->getVersion(),
  589.                 'api' => $this->_packagefile->getVersion(),
  590.             );
  591.         $arr['stability'] =
  592.             array(
  593.                 'release' => $this->_packagefile->getState(),
  594.                 'api' => $this->_packagefile->getState(),
  595.             );
  596.         $licensemap =
  597.             array(
  598.                 'php' => 'http://www.php.net/license',
  599.                 'php license' => 'http://www.php.net/license',
  600.                 'lgpl' => 'http://www.gnu.org/copyleft/lesser.html',
  601.                 'bsd' => 'http://www.opensource.org/licenses/bsd-license.php',
  602.                 'bsd style' => 'http://www.opensource.org/licenses/bsd-license.php',
  603.                 'bsd-style' => 'http://www.opensource.org/licenses/bsd-license.php',
  604.                 'mit' => 'http://www.opensource.org/licenses/mit-license.php',
  605.                 'gpl' => 'http://www.gnu.org/copyleft/gpl.html',
  606.                 'apache' => 'http://www.opensource.org/licenses/apache2.0.php'
  607.             );
  608.         if (isset($licensemap[strtolower($this->_packagefile->getLicense())])) {
  609.             $arr['license'] = array(
  610.                 'attribs' => array('uri' =>
  611.                     $licensemap[strtolower($this->_packagefile->getLicense())]),
  612.                 '_content' => $this->_packagefile->getLicense()
  613.                 );
  614.         } else {
  615.             // don't use bogus uri
  616.             $arr['license'] = $this->_packagefile->getLicense();
  617.         }
  618.         $arr['notes'] = $this->_packagefile->getNotes();
  619.         $temp = array();
  620.         $arr['contents'] = $this->_convertFilelist2_0($temp);
  621.         $this->_convertDependencies2_0($arr);
  622.         $release = ($this->_packagefile->getConfigureOptions() || $this->_isExtension) ?
  623.             'extsrcrelease' : 'phprelease';
  624.         if ($release == 'extsrcrelease') {
  625.             $arr['channel'] = 'pecl.php.net';
  626.             $arr['providesextension'] = $arr['name']; // assumption
  627.         }
  628.         $arr[$release] = array();
  629.         if ($this->_packagefile->getConfigureOptions()) {
  630.             $arr[$release]['configureoption'] = $this->_packagefile->getConfigureOptions();
  631.             foreach ($arr[$release]['configureoption'] as $i => $opt) {
  632.                 $arr[$release]['configureoption'][$i] = array('attribs' => $opt);
  633.             }
  634.             if (count($arr[$release]['configureoption']) == 1) {
  635.                 $arr[$release]['configureoption'] = $arr[$release]['configureoption'][0];
  636.             }
  637.         }
  638.         $this->_convertRelease2_0($arr[$release], $temp);
  639.         if ($release == 'extsrcrelease' && count($arr[$release]) > 1) {
  640.             // multiple extsrcrelease tags added in PEAR 1.4.1
  641.             $arr['dependencies']['required']['pearinstaller']['min'] = '1.4.1';
  642.         }
  643.         if ($cl = $this->_packagefile->getChangelog()) {
  644.             foreach ($cl as $release) {
  645.                 $rel = array();
  646.                 $rel['version'] =
  647.                     array(
  648.                         'release' => $release['version'],
  649.                         'api' => $release['version'],
  650.                     );
  651.                 if (!isset($release['release_state'])) {
  652.                     $release['release_state'] = 'stable';
  653.                 }
  654.                 $rel['stability'] =
  655.                     array(
  656.                         'release' => $release['release_state'],
  657.                         'api' => $release['release_state'],
  658.                     );
  659.                 if (isset($release['release_date'])) {
  660.                     $rel['date'] = $release['release_date'];
  661.                 } else {
  662.                     $rel['date'] = date('Y-m-d');
  663.                 }
  664.                 if (isset($release['release_license'])) {
  665.                     if (isset($licensemap[strtolower($release['release_license'])])) {
  666.                         $uri = $licensemap[strtolower($release['release_license'])];
  667.                     } else {
  668.                         $uri = 'http://www.example.com';
  669.                     }
  670.                     $rel['license'] = array(
  671.                             'attribs' => array('uri' => $uri),
  672.                             '_content' => $release['release_license']
  673.                         );
  674.                 } else {
  675.                     $rel['license'] = $arr['license'];
  676.                 }
  677.                 if (!isset($release['release_notes'])) {
  678.                     $release['release_notes'] = 'no release notes';
  679.                 }
  680.                 $rel['notes'] = $release['release_notes'];
  681.                 $arr['changelog']['release'][] = $rel;
  682.             }
  683.         }
  684.         $ret = new $class;
  685.         $ret->setConfig($this->_packagefile->_config);
  686.         if (isset($this->_packagefile->_logger) && is_object($this->_packagefile->_logger)) {
  687.             $ret->setLogger($this->_packagefile->_logger);
  688.         }
  689.         $ret->fromArray($arr);
  690.         return $ret;
  691.     }
  692.  
  693.     /**
  694.      * @param array
  695.      * @param bool
  696.      * @access private
  697.      */
  698.     function _convertDependencies2_0(&$release, $internal = false)
  699.     {
  700.         $peardep = array('pearinstaller' =>
  701.             array('min' => '1.4.0b1')); // this is a lot safer
  702.         $required = $optional = array();
  703.         $release['dependencies'] = array('required' => array());
  704.         if ($this->_packagefile->hasDeps()) {
  705.             foreach ($this->_packagefile->getDeps() as $dep) {
  706.                 if (!isset($dep['optional']) || $dep['optional'] == 'no') {
  707.                     $required[] = $dep;
  708.                 } else {
  709.                     $optional[] = $dep;
  710.                 }
  711.             }
  712.             foreach (array('required', 'optional') as $arr) {
  713.                 $deps = array();
  714.                 foreach ($$arr as $dep) {
  715.                     // organize deps by dependency type and name
  716.                     if (!isset($deps[$dep['type']])) {
  717.                         $deps[$dep['type']] = array();
  718.                     }
  719.                     if (isset($dep['name'])) {
  720.                         $deps[$dep['type']][$dep['name']][] = $dep;
  721.                     } else {
  722.                         $deps[$dep['type']][] = $dep;
  723.                     }
  724.                 }
  725.                 do {
  726.                     if (isset($deps['php'])) {
  727.                         $php = array();
  728.                         if (count($deps['php']) > 1) {
  729.                             $php = $this->_processPhpDeps($deps['php']);
  730.                         } else {
  731.                             if (!isset($deps['php'][0])) {
  732.                                 list($key, $blah) = each ($deps['php']); // stupid buggy versions
  733.                                 $deps['php'] = array($blah[0]);
  734.                             }
  735.                             $php = $this->_processDep($deps['php'][0]);
  736.                             if (!$php) {
  737.                                 break; // poor mans throw
  738.                             }
  739.                         }
  740.                         $release['dependencies'][$arr]['php'] = $php;
  741.                     }
  742.                 } while (false);
  743.                 do {
  744.                     if (isset($deps['pkg'])) {
  745.                         $pkg = array();
  746.                         $pkg = $this->_processMultipleDepsName($deps['pkg']);
  747.                         if (!$pkg) {
  748.                             break; // poor mans throw
  749.                         }
  750.                         $release['dependencies'][$arr]['package'] = $pkg;
  751.                     }
  752.                 } while (false);
  753.                 do {
  754.                     if (isset($deps['ext'])) {
  755.                         $pkg = array();
  756.                         $pkg = $this->_processMultipleDepsName($deps['ext']);
  757.                         $release['dependencies'][$arr]['extension'] = $pkg;
  758.                     }
  759.                 } while (false);
  760.                 // skip sapi - it's not supported so nobody will have used it
  761.                 // skip os - it's not supported in 1.0
  762.             }
  763.         }
  764.         if (isset($release['dependencies']['required'])) {
  765.             $release['dependencies']['required'] =
  766.                 array_merge($peardep, $release['dependencies']['required']);
  767.         } else {
  768.             $release['dependencies']['required'] = $peardep;
  769.         }
  770.         if (!isset($release['dependencies']['required']['php'])) {
  771.             $release['dependencies']['required']['php'] =
  772.                 array('min' => '4.0.0');
  773.         }
  774.         $order = array();
  775.         $bewm = $release['dependencies']['required'];
  776.         $order['php'] = $bewm['php'];
  777.         $order['pearinstaller'] = $bewm['pearinstaller'];
  778.         isset($bewm['package']) ? $order['package'] = $bewm['package'] :0;
  779.         isset($bewm['extension']) ? $order['extension'] = $bewm['extension'] :0;
  780.         $release['dependencies']['required'] = $order;
  781.     }
  782.  
  783.     /**
  784.      * @param array
  785.      * @access private
  786.      */
  787.     function _convertFilelist2_0(&$package)
  788.     {
  789.         $ret = array('dir' =>
  790.                     array(
  791.                         'attribs' => array('name' => '/'),
  792.                         'file' => array()
  793.                         )
  794.                     );
  795.         $package['platform'] =
  796.         $package['install-as'] = array();
  797.         $this->_isExtension = false;
  798.         foreach ($this->_packagefile->getFilelist() as $name => $file) {
  799.             $file['name'] = $name;
  800.             if (isset($file['role']) && $file['role'] == 'src') {
  801.                 $this->_isExtension = true;
  802.             }
  803.             if (isset($file['replacements'])) {
  804.                 $repl = $file['replacements'];
  805.                 unset($file['replacements']);
  806.             } else {
  807.                 unset($repl);
  808.             }
  809.             if (isset($file['install-as'])) {
  810.                 $package['install-as'][$name] = $file['install-as'];
  811.                 unset($file['install-as']);
  812.             }
  813.             if (isset($file['platform'])) {
  814.                 $package['platform'][$name] = $file['platform'];
  815.                 unset($file['platform']);
  816.             }
  817.             $file = array('attribs' => $file);
  818.             if (isset($repl)) {
  819.                 foreach ($repl as $replace ) {
  820.                     $file['tasks:replace'][] = array('attribs' => $replace);
  821.                 }
  822.                 if (count($repl) == 1) {
  823.                     $file['tasks:replace'] = $file['tasks:replace'][0];
  824.                 }
  825.             }
  826.             $ret['dir']['file'][] = $file;
  827.         }
  828.         return $ret;
  829.     }
  830.  
  831.     /**
  832.      * Post-process special files with install-as/platform attributes and
  833.      * make the release tag.
  834.      * 
  835.      * This complex method follows this work-flow to create the release tags:
  836.      * 
  837.      * <pre>
  838.      * - if any install-as/platform exist, create a generic release and fill it with
  839.      *   o <install as=..> tags for <file name=... install-as=...>
  840.      *   o <install as=..> tags for <file name=... platform=!... install-as=..>
  841.      *   o <ignore> tags for <file name=... platform=...>
  842.      *   o <ignore> tags for <file name=... platform=... install-as=..>
  843.      * - create a release for each platform encountered and fill with
  844.      *   o <install as..> tags for <file name=... install-as=...>
  845.      *   o <install as..> tags for <file name=... platform=this platform install-as=..>
  846.      *   o <install as..> tags for <file name=... platform=!other platform install-as=..>
  847.      *   o <ignore> tags for <file name=... platform=!this platform>
  848.      *   o <ignore> tags for <file name=... platform=other platform>
  849.      *   o <ignore> tags for <file name=... platform=other platform install-as=..>
  850.      *   o <ignore> tags for <file name=... platform=!this platform install-as=..>
  851.      * </pre>
  852.      * 
  853.      * It does this by accessing the $package parameter, which contains an array with
  854.      * indices:
  855.      * 
  856.      *  - platform: mapping of file => OS the file should be installed on
  857.      *  - install-as: mapping of file => installed name
  858.      *  - osmap: mapping of OS => list of files that should be installed
  859.      *    on that OS
  860.      *  - notosmap: mapping of OS => list of files that should not be
  861.      *    installed on that OS
  862.      *
  863.      * @param array
  864.      * @param array
  865.      * @access private
  866.      */
  867.     function _convertRelease2_0(&$release, $package)
  868.     {
  869.         //- if any install-as/platform exist, create a generic release and fill it with 
  870.         if (count($package['platform']) || count($package['install-as'])) {
  871.             $generic = array();
  872.             $genericIgnore = array();
  873.             foreach ($package['install-as'] as $file => $as) {
  874.                 //o <install as=..> tags for <file name=... install-as=...>
  875.                 if (!isset($package['platform'][$file])) {
  876.                     $generic[] = $file;
  877.                     continue;
  878.                 }
  879.                 //o <install as=..> tags for <file name=... platform=!... install-as=..>
  880.                 if (isset($package['platform'][$file]) &&
  881.                       $package['platform'][$file]{0} == '!') {
  882.                     $generic[] = $file;
  883.                     continue;
  884.                 }
  885.                 //o <ignore> tags for <file name=... platform=... install-as=..>
  886.                 if (isset($package['platform'][$file]) &&
  887.                       $package['platform'][$file]{0} != '!') {
  888.                     $genericIgnore[] = $file;
  889.                     continue;
  890.                 }
  891.             }
  892.             foreach ($package['platform'] as $file => $platform) {
  893.                 if (isset($package['install-as'][$file])) {
  894.                     continue;
  895.                 }
  896.                 if ($platform{0} != '!') {
  897.                     //o <ignore> tags for <file name=... platform=...>
  898.                     $genericIgnore[] = $file;
  899.                 }
  900.             }
  901.             if (count($package['platform'])) {
  902.                 $oses = $notplatform = $platform = array();
  903.                 foreach ($package['platform'] as $file => $os) {
  904.                     // get a list of oses
  905.                     if ($os{0} == '!') {
  906.                         if (isset($oses[substr($os, 1)])) {
  907.                             continue;
  908.                         }
  909.                         $oses[substr($os, 1)] = count($oses);
  910.                     } else {
  911.                         if (isset($oses[$os])) {
  912.                             continue;
  913.                         }
  914.                         $oses[$os] = count($oses);
  915.                     }
  916.                 }
  917.                 //- create a release for each platform encountered and fill with
  918.                 foreach ($oses as $os => $releaseNum) {
  919.                     $release[$releaseNum]['installconditions']['os']['name'] = $os;
  920.                     $release[$releaseNum]['filelist'] = array('install' => array(),
  921.                         'ignore' => array());
  922.                     foreach ($package['install-as'] as $file => $as) {
  923.                         //o <install as=..> tags for <file name=... install-as=...>
  924.                         if (!isset($package['platform'][$file])) {
  925.                             $release[$releaseNum]['filelist']['install'][] =
  926.                                 array(
  927.                                     'attribs' => array(
  928.                                         'name' => $file,
  929.                                         'as' => $as,
  930.                                     ),
  931.                                 );
  932.                             continue;
  933.                         }
  934.                         //o <install as..> tags for
  935.                         //  <file name=... platform=this platform install-as=..>
  936.                         if (isset($package['platform'][$file]) &&
  937.                               $package['platform'][$file] == $os) {
  938.                             $release[$releaseNum]['filelist']['install'][] =
  939.                                 array(
  940.                                     'attribs' => array(
  941.                                         'name' => $file,
  942.                                         'as' => $as,
  943.                                     ),
  944.                                 );
  945.                             continue;
  946.                         }
  947.                         //o <install as..> tags for
  948.                         //  <file name=... platform=!other platform install-as=..>
  949.                         if (isset($package['platform'][$file]) &&
  950.                               $package['platform'][$file] != "!$os" &&
  951.                               $package['platform'][$file]{0} == '!') {
  952.                             $release[$releaseNum]['filelist']['install'][] =
  953.                                 array(
  954.                                     'attribs' => array(
  955.                                         'name' => $file,
  956.                                         'as' => $as,
  957.                                     ),
  958.                                 );
  959.                             continue;
  960.                         }
  961.                         //o <ignore> tags for
  962.                         //  <file name=... platform=!this platform install-as=..>
  963.                         if (isset($package['platform'][$file]) &&
  964.                               $package['platform'][$file] == "!$os") {
  965.                             $release[$releaseNum]['filelist']['ignore'][] =
  966.                                 array(
  967.                                     'attribs' => array(
  968.                                         'name' => $file,
  969.                                     ),
  970.                                 );
  971.                             continue;
  972.                         }
  973.                         //o <ignore> tags for
  974.                         //  <file name=... platform=other platform install-as=..>
  975.                         if (isset($package['platform'][$file]) &&
  976.                               $package['platform'][$file]{0} != '!' &&
  977.                               $package['platform'][$file] != $os) {
  978.                             $release[$releaseNum]['filelist']['ignore'][] =
  979.                                 array(
  980.                                     'attribs' => array(
  981.                                         'name' => $file,
  982.                                     ),
  983.                                 );
  984.                             continue;
  985.                         }
  986.                     }
  987.                     foreach ($package['platform'] as $file => $platform) {
  988.                         if (isset($package['install-as'][$file])) {
  989.                             continue;
  990.                         }
  991.                         //o <ignore> tags for <file name=... platform=!this platform>
  992.                         if ($platform == "!$os") {
  993.                             $release[$releaseNum]['filelist']['ignore'][] =
  994.                                 array(
  995.                                     'attribs' => array(
  996.                                         'name' => $file,
  997.                                     ),
  998.                                 );
  999.                             continue;
  1000.                         }
  1001.                         //o <ignore> tags for <file name=... platform=other platform>
  1002.                         if ($platform{0} != '!' && $platform != $os) {
  1003.                             $release[$releaseNum]['filelist']['ignore'][] =
  1004.                                 array(
  1005.                                     'attribs' => array(
  1006.                                         'name' => $file,
  1007.                                     ),
  1008.                                 );
  1009.                         }
  1010.                     }
  1011.                     if (!count($release[$releaseNum]['filelist']['install'])) {
  1012.                         unset($release[$releaseNum]['filelist']['install']);
  1013.                     }
  1014.                     if (!count($release[$releaseNum]['filelist']['ignore'])) {
  1015.                         unset($release[$releaseNum]['filelist']['ignore']);
  1016.                     }
  1017.                 }
  1018.                 if (count($generic) || count($genericIgnore)) {
  1019.                     $release[count($oses)] = array();
  1020.                     if (count($generic)) {
  1021.                         foreach ($generic as $file) {
  1022.                             if (isset($package['install-as'][$file])) {
  1023.                                 $installas = $package['install-as'][$file];
  1024.                             } else {
  1025.                                 $installas = $file;
  1026.                             }
  1027.                             $release[count($oses)]['filelist']['install'][] =
  1028.                                 array(
  1029.                                     'attribs' => array(
  1030.                                         'name' => $file,
  1031.                                         'as' => $installas,
  1032.                                     )
  1033.                                 );
  1034.                         }
  1035.                     }
  1036.                     if (count($genericIgnore)) {
  1037.                         foreach ($genericIgnore as $file) {
  1038.                             $release[count($oses)]['filelist']['ignore'][] =
  1039.                                 array(
  1040.                                     'attribs' => array(
  1041.                                         'name' => $file,
  1042.                                     )
  1043.                                 );
  1044.                         }
  1045.                     }
  1046.                 }
  1047.                 // cleanup
  1048.                 foreach ($release as $i => $rel) {
  1049.                     if (isset($rel['filelist']['install']) &&
  1050.                           count($rel['filelist']['install']) == 1) {
  1051.                         $release[$i]['filelist']['install'] =
  1052.                             $release[$i]['filelist']['install'][0];
  1053.                     }
  1054.                     if (isset($rel['filelist']['ignore']) &&
  1055.                           count($rel['filelist']['ignore']) == 1) {
  1056.                         $release[$i]['filelist']['ignore'] =
  1057.                             $release[$i]['filelist']['ignore'][0];
  1058.                     }
  1059.                 }
  1060.                 if (count($release) == 1) {
  1061.                     $release = $release[0];
  1062.                 }
  1063.             } else {
  1064.                 // no platform atts, but some install-as atts
  1065.                 foreach ($package['install-as'] as $file => $value) {
  1066.                     $release['filelist']['install'][] =
  1067.                         array(
  1068.                             'attribs' => array(
  1069.                                 'name' => $file,
  1070.                                 'as' => $value
  1071.                             )
  1072.                         );
  1073.                 }
  1074.                 if (count($release['filelist']['install']) == 1) {
  1075.                     $release['filelist']['install'] = $release['filelist']['install'][0];
  1076.                 }
  1077.             }
  1078.         }
  1079.     }
  1080.  
  1081.     /**
  1082.      * @param array
  1083.      * @return array
  1084.      * @access private
  1085.      */
  1086.     function _processDep($dep)
  1087.     {
  1088.         if ($dep['type'] == 'php') {
  1089.             if ($dep['rel'] == 'has') {
  1090.                 // come on - everyone has php!
  1091.                 return false;
  1092.             }
  1093.         }
  1094.         $php = array();
  1095.         if ($dep['type'] != 'php') {
  1096.             $php['name'] = $dep['name'];
  1097.             if ($dep['type'] == 'pkg') {
  1098.                 $php['channel'] = 'pear.php.net';
  1099.             }
  1100.         }
  1101.         switch ($dep['rel']) {
  1102.             case 'gt' :
  1103.                 $php['min'] = $dep['version'];
  1104.                 $php['exclude'] = $dep['version'];
  1105.             break;
  1106.             case 'ge' :
  1107.                 if (!isset($dep['version'])) {
  1108.                     if ($dep['type'] == 'php') {
  1109.                         if (isset($dep['name'])) {
  1110.                             $dep['version'] = $dep['name'];
  1111.                         }
  1112.                     }
  1113.                 }
  1114.                 $php['min'] = $dep['version'];
  1115.             break;
  1116.             case 'lt' :
  1117.                 $php['max'] = $dep['version'];
  1118.                 $php['exclude'] = $dep['version'];
  1119.             break;
  1120.             case 'le' :
  1121.                 $php['max'] = $dep['version'];
  1122.             break;
  1123.             case 'eq' :
  1124.                 $php['min'] = $dep['version'];
  1125.                 $php['max'] = $dep['version'];
  1126.             break;
  1127.             case 'ne' :
  1128.                 $php['exclude'] = $dep['version'];
  1129.             break;
  1130.             case 'not' :
  1131.                 $php['conflicts'] = 'yes';
  1132.             break;
  1133.         }
  1134.         return $php;
  1135.     }
  1136.  
  1137.     /**
  1138.      * @param array
  1139.      * @return array
  1140.      */
  1141.     function _processPhpDeps($deps)
  1142.     {
  1143.         $test = array();
  1144.         foreach ($deps as $dep) {
  1145.             $test[] = $this->_processDep($dep);
  1146.         }
  1147.         $min = array();
  1148.         $max = array();
  1149.         foreach ($test as $dep) {
  1150.             if (!$dep) {
  1151.                 continue;
  1152.             }
  1153.             if (isset($dep['min'])) {
  1154.                 $min[$dep['min']] = count($min);
  1155.             }
  1156.             if (isset($dep['max'])) {
  1157.                 $max[$dep['max']] = count($max);
  1158.             }
  1159.         }
  1160.         if (count($min) > 0) {
  1161.             uksort($min, 'version_compare');
  1162.         }
  1163.         if (count($max) > 0) {
  1164.             uksort($max, 'version_compare');
  1165.         }
  1166.         if (count($min)) {
  1167.             // get the highest minimum
  1168.             $min = array_pop($a = array_flip($min));
  1169.         } else {
  1170.             $min = false;
  1171.         }
  1172.         if (count($max)) {
  1173.             // get the lowest maximum
  1174.             $max = array_shift($a = array_flip($max));
  1175.         } else {
  1176.             $max = false;
  1177.         }
  1178.         if ($min) {
  1179.             $php['min'] = $min;
  1180.         }
  1181.         if ($max) {
  1182.             $php['max'] = $max;
  1183.         }
  1184.         $exclude = array();
  1185.         foreach ($test as $dep) {
  1186.             if (!isset($dep['exclude'])) {
  1187.                 continue;
  1188.             }
  1189.             $exclude[] = $dep['exclude'];
  1190.         }
  1191.         if (count($exclude)) {
  1192.             $php['exclude'] = $exclude;
  1193.         }
  1194.         return $php;
  1195.     }
  1196.  
  1197.     /**
  1198.      * process multiple dependencies that have a name, like package deps
  1199.      * @param array
  1200.      * @return array
  1201.      * @access private
  1202.      */
  1203.     function _processMultipleDepsName($deps)
  1204.     {
  1205.         $tests = array();
  1206.         foreach ($deps as $name => $dep) {
  1207.             foreach ($dep as $d) {
  1208.                 $tests[$name][] = $this->_processDep($d);
  1209.             }
  1210.         }
  1211.         foreach ($tests as $name => $test) {
  1212.             $php = array();
  1213.             $min = array();
  1214.             $max = array();
  1215.             $php['name'] = $name;
  1216.             foreach ($test as $dep) {
  1217.                 if (!$dep) {
  1218.                     continue;
  1219.                 }
  1220.                 if (isset($dep['channel'])) {
  1221.                     $php['channel'] = 'pear.php.net';
  1222.                 }
  1223.                 if (isset($dep['conflicts']) && $dep['conflicts'] == 'yes') {
  1224.                     $php['conflicts'] = 'yes';
  1225.                 }
  1226.                 if (isset($dep['min'])) {
  1227.                     $min[$dep['min']] = count($min);
  1228.                 }
  1229.                 if (isset($dep['max'])) {
  1230.                     $max[$dep['max']] = count($max);
  1231.                 }
  1232.             }
  1233.             if (count($min) > 0) {
  1234.                 uksort($min, 'version_compare');
  1235.             }
  1236.             if (count($max) > 0) {
  1237.                 uksort($max, 'version_compare');
  1238.             }
  1239.             if (count($min)) {
  1240.                 // get the highest minimum
  1241.                 $min = array_pop($a = array_flip($min));
  1242.             } else {
  1243.                 $min = false;
  1244.             }
  1245.             if (count($max)) {
  1246.                 // get the lowest maximum
  1247.                 $max = array_shift($a = array_flip($max));
  1248.             } else {
  1249.                 $max = false;
  1250.             }
  1251.             if ($min) {
  1252.                 $php['min'] = $min;
  1253.             }
  1254.             if ($max) {
  1255.                 $php['max'] = $max;
  1256.             }
  1257.             $exclude = array();
  1258.             foreach ($test as $dep) {
  1259.                 if (!isset($dep['exclude'])) {
  1260.                     continue;
  1261.                 }
  1262.                 $exclude[] = $dep['exclude'];
  1263.             }
  1264.             if (count($exclude)) {
  1265.                 $php['exclude'] = $exclude;
  1266.             }
  1267.             $ret[] = $php;
  1268.         }
  1269.         return $ret;
  1270.     }
  1271. }
  1272. ?>