source: trunk/library/PEAR/PEAR/PackageFile/Generator/v1.php @ 7730

Revision 7730, 49.3 KB checked in by marcieli, 11 years ago (diff)

Ticket #3236 - Correcoes de seguranca com base no segundo relatorio emitido.

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