+ * @access private
+ * @global array $GLOBALS['_PEAR_ERRORSTACK_SINGLETON']
+ */
+$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] = array();
+
+/**
+ * Global error callback (default)
+ *
+ * This is only used if set to non-false. * is the default callback for
+ * all packages, whereas specific packages may set a default callback
+ * for all instances, regardless of whether they are a singleton or not.
+ *
+ * To exclude non-singletons, only set the local callback for the singleton
+ * @see PEAR_ErrorStack::setDefaultCallback()
+ * @access private
+ * @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']
+ */
+$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'] = array(
+ '*' => false,
+);
+
+/**
+ * Global Log object (default)
+ *
+ * This is only used if set to non-false. Use to set a default log object for
+ * all stacks, regardless of instantiation order or location
+ * @see PEAR_ErrorStack::setDefaultLogger()
+ * @access private
+ * @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']
+ */
+$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = false;
+
+/**
+ * Global Overriding Callback
+ *
+ * This callback will override any error callbacks that specific loggers have set.
+ * Use with EXTREME caution
+ * @see PEAR_ErrorStack::staticPushCallback()
+ * @access private
+ * @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']
+ */
+$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
+
+/**#@+
+ * One of four possible return values from the error Callback
+ * @see PEAR_ErrorStack::_errorCallback()
+ */
+/**
+ * If this is returned, then the error will be both pushed onto the stack
+ * and logged.
+ */
+define('PEAR_ERRORSTACK_PUSHANDLOG', 1);
+/**
+ * If this is returned, then the error will only be pushed onto the stack,
+ * and not logged.
+ */
+define('PEAR_ERRORSTACK_PUSH', 2);
+/**
+ * If this is returned, then the error will only be logged, but not pushed
+ * onto the error stack.
+ */
+define('PEAR_ERRORSTACK_LOG', 3);
+/**
+ * If this is returned, then the error is completely ignored.
+ */
+define('PEAR_ERRORSTACK_IGNORE', 4);
+/**
+ * If this is returned, then the error is logged and die() is called.
+ */
+define('PEAR_ERRORSTACK_DIE', 5);
+/**#@-*/
+
+/**
+ * Error code for an attempt to instantiate a non-class as a PEAR_ErrorStack in
+ * the singleton method.
+ */
+define('PEAR_ERRORSTACK_ERR_NONCLASS', 1);
+
+/**
+ * Error code for an attempt to pass an object into {@link PEAR_ErrorStack::getMessage()}
+ * that has no __toString() method
+ */
+define('PEAR_ERRORSTACK_ERR_OBJTOSTRING', 2);
+/**
+ * Error Stack Implementation
+ *
+ * Usage:
+ *
+ * // global error stack
+ * $global_stack = &PEAR_ErrorStack::singleton('MyPackage');
+ * // local error stack
+ * $local_stack = new PEAR_ErrorStack('MyPackage');
+ *
+ * @author Greg Beaver
+ * @version 1.10.1
+ * @package PEAR_ErrorStack
+ * @category Debugging
+ * @copyright 2004-2008 Greg Beaver
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR_ErrorStack
+ */
+class PEAR_ErrorStack {
+ /**
+ * Errors are stored in the order that they are pushed on the stack.
+ * @since 0.4alpha Errors are no longer organized by error level.
+ * This renders pop() nearly unusable, and levels could be more easily
+ * handled in a callback anyway
+ * @var array
+ * @access private
+ */
+ var $_errors = array();
+
+ /**
+ * Storage of errors by level.
+ *
+ * Allows easy retrieval and deletion of only errors from a particular level
+ * @since PEAR 1.4.0dev
+ * @var array
+ * @access private
+ */
+ var $_errorsByLevel = array();
+
+ /**
+ * Package name this error stack represents
+ * @var string
+ * @access protected
+ */
+ var $_package;
+
+ /**
+ * Determines whether a PEAR_Error is thrown upon every error addition
+ * @var boolean
+ * @access private
+ */
+ var $_compat = false;
+
+ /**
+ * If set to a valid callback, this will be used to generate the error
+ * message from the error code, otherwise the message passed in will be
+ * used
+ * @var false|string|array
+ * @access private
+ */
+ var $_msgCallback = false;
+
+ /**
+ * If set to a valid callback, this will be used to generate the error
+ * context for an error. For PHP-related errors, this will be a file
+ * and line number as retrieved from debug_backtrace(), but can be
+ * customized for other purposes. The error might actually be in a separate
+ * configuration file, or in a database query.
+ * @var false|string|array
+ * @access protected
+ */
+ var $_contextCallback = false;
+
+ /**
+ * If set to a valid callback, this will be called every time an error
+ * is pushed onto the stack. The return value will be used to determine
+ * whether to allow an error to be pushed or logged.
+ *
+ * The return value must be one an PEAR_ERRORSTACK_* constant
+ * @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
+ * @var false|string|array
+ * @access protected
+ */
+ var $_errorCallback = array();
+
+ /**
+ * PEAR::Log object for logging errors
+ * @var false|Log
+ * @access protected
+ */
+ var $_logger = false;
+
+ /**
+ * Error messages - designed to be overridden
+ * @var array
+ * @abstract
+ */
+ var $_errorMsgs = array();
+
+ /**
+ * Set up a new error stack
+ *
+ * @param string $package name of the package this error stack represents
+ * @param callback $msgCallback callback used for error message generation
+ * @param callback $contextCallback callback used for context generation,
+ * defaults to {@link getFileLine()}
+ * @param boolean $throwPEAR_Error
+ */
+ function __construct($package, $msgCallback = false, $contextCallback = false,
+ $throwPEAR_Error = false)
+ {
+ $this->_package = $package;
+ $this->setMessageCallback($msgCallback);
+ $this->setContextCallback($contextCallback);
+ $this->_compat = $throwPEAR_Error;
+ }
+
+ /**
+ * Return a single error stack for this package.
+ *
+ * Note that all parameters are ignored if the stack for package $package
+ * has already been instantiated
+ * @param string $package name of the package this error stack represents
+ * @param callback $msgCallback callback used for error message generation
+ * @param callback $contextCallback callback used for context generation,
+ * defaults to {@link getFileLine()}
+ * @param boolean $throwPEAR_Error
+ * @param string $stackClass class to instantiate
+ *
+ * @return PEAR_ErrorStack
+ */
+ public static function &singleton(
+ $package, $msgCallback = false, $contextCallback = false,
+ $throwPEAR_Error = false, $stackClass = 'PEAR_ErrorStack'
+ ) {
+ if (isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
+ return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];
+ }
+ if (!class_exists($stackClass)) {
+ if (function_exists('debug_backtrace')) {
+ $trace = debug_backtrace();
+ }
+ PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_NONCLASS,
+ 'exception', array('stackclass' => $stackClass),
+ 'stack class "%stackclass%" is not a valid class name (should be like PEAR_ErrorStack)',
+ false, $trace);
+ }
+ $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package] =
+ new $stackClass($package, $msgCallback, $contextCallback, $throwPEAR_Error);
+
+ return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];
+ }
+
+ /**
+ * Internal error handler for PEAR_ErrorStack class
+ *
+ * Dies if the error is an exception (and would have died anyway)
+ * @access private
+ */
+ function _handleError($err)
+ {
+ if ($err['level'] == 'exception') {
+ $message = $err['message'];
+ if (isset($_SERVER['REQUEST_URI'])) {
+ echo ' ';
+ } else {
+ echo "\n";
+ }
+ var_dump($err['context']);
+ die($message);
+ }
+ }
+
+ /**
+ * Set up a PEAR::Log object for all error stacks that don't have one
+ * @param Log $log
+ */
+ public static function setDefaultLogger(&$log)
+ {
+ if (is_object($log) && method_exists($log, 'log') ) {
+ $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
+ } elseif (is_callable($log)) {
+ $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
+ }
+ }
+
+ /**
+ * Set up a PEAR::Log object for this error stack
+ * @param Log $log
+ */
+ function setLogger(&$log)
+ {
+ if (is_object($log) && method_exists($log, 'log') ) {
+ $this->_logger = &$log;
+ } elseif (is_callable($log)) {
+ $this->_logger = &$log;
+ }
+ }
+
+ /**
+ * Set an error code => error message mapping callback
+ *
+ * This method sets the callback that can be used to generate error
+ * messages for any instance
+ * @param array|string Callback function/method
+ */
+ function setMessageCallback($msgCallback)
+ {
+ if (!$msgCallback) {
+ $this->_msgCallback = array(&$this, 'getErrorMessage');
+ } else {
+ if (is_callable($msgCallback)) {
+ $this->_msgCallback = $msgCallback;
+ }
+ }
+ }
+
+ /**
+ * Get an error code => error message mapping callback
+ *
+ * This method returns the current callback that can be used to generate error
+ * messages
+ * @return array|string|false Callback function/method or false if none
+ */
+ function getMessageCallback()
+ {
+ return $this->_msgCallback;
+ }
+
+ /**
+ * Sets a default callback to be used by all error stacks
+ *
+ * This method sets the callback that can be used to generate error
+ * messages for a singleton
+ * @param array|string Callback function/method
+ * @param string Package name, or false for all packages
+ */
+ public static function setDefaultCallback($callback = false, $package = false)
+ {
+ if (!is_callable($callback)) {
+ $callback = false;
+ }
+ $package = $package ? $package : '*';
+ $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$package] = $callback;
+ }
+
+ /**
+ * Set a callback that generates context information (location of error) for an error stack
+ *
+ * This method sets the callback that can be used to generate context
+ * information for an error. Passing in NULL will disable context generation
+ * and remove the expensive call to debug_backtrace()
+ * @param array|string|null Callback function/method
+ */
+ function setContextCallback($contextCallback)
+ {
+ if ($contextCallback === null) {
+ return $this->_contextCallback = false;
+ }
+ if (!$contextCallback) {
+ $this->_contextCallback = array(&$this, 'getFileLine');
+ } else {
+ if (is_callable($contextCallback)) {
+ $this->_contextCallback = $contextCallback;
+ }
+ }
+ }
+
+ /**
+ * Set an error Callback
+ * If set to a valid callback, this will be called every time an error
+ * is pushed onto the stack. The return value will be used to determine
+ * whether to allow an error to be pushed or logged.
+ *
+ * The return value must be one of the ERRORSTACK_* constants.
+ *
+ * This functionality can be used to emulate PEAR's pushErrorHandling, and
+ * the PEAR_ERROR_CALLBACK mode, without affecting the integrity of
+ * the error stack or logging
+ * @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
+ * @see popCallback()
+ * @param string|array $cb
+ */
+ function pushCallback($cb)
+ {
+ array_push($this->_errorCallback, $cb);
+ }
+
+ /**
+ * Remove a callback from the error callback stack
+ * @see pushCallback()
+ * @return array|string|false
+ */
+ function popCallback()
+ {
+ if (!count($this->_errorCallback)) {
+ return false;
+ }
+ return array_pop($this->_errorCallback);
+ }
+
+ /**
+ * Set a temporary overriding error callback for every package error stack
+ *
+ * Use this to temporarily disable all existing callbacks (can be used
+ * to emulate the @ operator, for instance)
+ * @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
+ * @see staticPopCallback(), pushCallback()
+ * @param string|array $cb
+ */
+ public static function staticPushCallback($cb)
+ {
+ array_push($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'], $cb);
+ }
+
+ /**
+ * Remove a temporary overriding error callback
+ * @see staticPushCallback()
+ * @return array|string|false
+ */
+ public static function staticPopCallback()
+ {
+ $ret = array_pop($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK']);
+ if (!is_array($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'])) {
+ $GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
+ }
+ return $ret;
+ }
+
+ /**
+ * Add an error to the stack
+ *
+ * If the message generator exists, it is called with 2 parameters.
+ * - the current Error Stack object
+ * - an array that is in the same format as an error. Available indices
+ * are 'code', 'package', 'time', 'params', 'level', and 'context'
+ *
+ * Next, if the error should contain context information, this is
+ * handled by the context grabbing method.
+ * Finally, the error is pushed onto the proper error stack
+ * @param int $code Package-specific error code
+ * @param string $level Error level. This is NOT spell-checked
+ * @param array $params associative array of error parameters
+ * @param string $msg Error message, or a portion of it if the message
+ * is to be generated
+ * @param array $repackage If this error re-packages an error pushed by
+ * another package, place the array returned from
+ * {@link pop()} in this parameter
+ * @param array $backtrace Protected parameter: use this to pass in the
+ * {@link debug_backtrace()} that should be used
+ * to find error context
+ * @return PEAR_Error|array if compatibility mode is on, a PEAR_Error is also
+ * thrown. If a PEAR_Error is returned, the userinfo
+ * property is set to the following array:
+ *
+ *
+ * array(
+ * 'code' => $code,
+ * 'params' => $params,
+ * 'package' => $this->_package,
+ * 'level' => $level,
+ * 'time' => time(),
+ * 'context' => $context,
+ * 'message' => $msg,
+ * //['repackage' => $err] repackaged error array/Exception class
+ * );
+ *
+ *
+ * Normally, the previous array is returned.
+ */
+ function push($code, $level = 'error', $params = array(), $msg = false,
+ $repackage = false, $backtrace = false)
+ {
+ $context = false;
+ // grab error context
+ if ($this->_contextCallback) {
+ if (!$backtrace) {
+ $backtrace = debug_backtrace();
+ }
+ $context = call_user_func($this->_contextCallback, $code, $params, $backtrace);
+ }
+
+ // save error
+ $time = explode(' ', microtime());
+ $time = $time[1] + $time[0];
+ $err = array(
+ 'code' => $code,
+ 'params' => $params,
+ 'package' => $this->_package,
+ 'level' => $level,
+ 'time' => $time,
+ 'context' => $context,
+ 'message' => $msg,
+ );
+
+ if ($repackage) {
+ $err['repackage'] = $repackage;
+ }
+
+ // set up the error message, if necessary
+ if ($this->_msgCallback) {
+ $msg = call_user_func_array($this->_msgCallback,
+ array(&$this, $err));
+ $err['message'] = $msg;
+ }
+ $push = $log = true;
+ $die = false;
+ // try the overriding callback first
+ $callback = $this->staticPopCallback();
+ if ($callback) {
+ $this->staticPushCallback($callback);
+ }
+ if (!is_callable($callback)) {
+ // try the local callback next
+ $callback = $this->popCallback();
+ if (is_callable($callback)) {
+ $this->pushCallback($callback);
+ } else {
+ // try the default callback
+ $callback = isset($GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$this->_package]) ?
+ $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$this->_package] :
+ $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']['*'];
+ }
+ }
+ if (is_callable($callback)) {
+ switch(call_user_func($callback, $err)){
+ case PEAR_ERRORSTACK_IGNORE:
+ return $err;
+ break;
+ case PEAR_ERRORSTACK_PUSH:
+ $log = false;
+ break;
+ case PEAR_ERRORSTACK_LOG:
+ $push = false;
+ break;
+ case PEAR_ERRORSTACK_DIE:
+ $die = true;
+ break;
+ // anything else returned has the same effect as pushandlog
+ }
+ }
+ if ($push) {
+ array_unshift($this->_errors, $err);
+ if (!isset($this->_errorsByLevel[$err['level']])) {
+ $this->_errorsByLevel[$err['level']] = array();
+ }
+ $this->_errorsByLevel[$err['level']][] = &$this->_errors[0];
+ }
+ if ($log) {
+ if ($this->_logger || $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']) {
+ $this->_log($err);
+ }
+ }
+ if ($die) {
+ die();
+ }
+ if ($this->_compat && $push) {
+ return $this->raiseError($msg, $code, null, null, $err);
+ }
+ return $err;
+ }
+
+ /**
+ * Static version of {@link push()}
+ *
+ * @param string $package Package name this error belongs to
+ * @param int $code Package-specific error code
+ * @param string $level Error level. This is NOT spell-checked
+ * @param array $params associative array of error parameters
+ * @param string $msg Error message, or a portion of it if the message
+ * is to be generated
+ * @param array $repackage If this error re-packages an error pushed by
+ * another package, place the array returned from
+ * {@link pop()} in this parameter
+ * @param array $backtrace Protected parameter: use this to pass in the
+ * {@link debug_backtrace()} that should be used
+ * to find error context
+ * @return PEAR_Error|array if compatibility mode is on, a PEAR_Error is also
+ * thrown. see docs for {@link push()}
+ */
+ public static function staticPush(
+ $package, $code, $level = 'error', $params = array(),
+ $msg = false, $repackage = false, $backtrace = false
+ ) {
+ $s = &PEAR_ErrorStack::singleton($package);
+ if ($s->_contextCallback) {
+ if (!$backtrace) {
+ if (function_exists('debug_backtrace')) {
+ $backtrace = debug_backtrace();
+ }
+ }
+ }
+ return $s->push($code, $level, $params, $msg, $repackage, $backtrace);
+ }
+
+ /**
+ * Log an error using PEAR::Log
+ * @param array $err Error array
+ * @param array $levels Error level => Log constant map
+ * @access protected
+ */
+ function _log($err)
+ {
+ if ($this->_logger) {
+ $logger = &$this->_logger;
+ } else {
+ $logger = &$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'];
+ }
+ if (is_a($logger, 'Log')) {
+ $levels = array(
+ 'exception' => PEAR_LOG_CRIT,
+ 'alert' => PEAR_LOG_ALERT,
+ 'critical' => PEAR_LOG_CRIT,
+ 'error' => PEAR_LOG_ERR,
+ 'warning' => PEAR_LOG_WARNING,
+ 'notice' => PEAR_LOG_NOTICE,
+ 'info' => PEAR_LOG_INFO,
+ 'debug' => PEAR_LOG_DEBUG);
+ if (isset($levels[$err['level']])) {
+ $level = $levels[$err['level']];
+ } else {
+ $level = PEAR_LOG_INFO;
+ }
+ $logger->log($err['message'], $level, $err);
+ } else { // support non-standard logs
+ call_user_func($logger, $err);
+ }
+ }
+
+
+ /**
+ * Pop an error off of the error stack
+ *
+ * @return false|array
+ * @since 0.4alpha it is no longer possible to specify a specific error
+ * level to return - the last error pushed will be returned, instead
+ */
+ function pop()
+ {
+ $err = @array_shift($this->_errors);
+ if (!is_null($err)) {
+ @array_pop($this->_errorsByLevel[$err['level']]);
+ if (!count($this->_errorsByLevel[$err['level']])) {
+ unset($this->_errorsByLevel[$err['level']]);
+ }
+ }
+ return $err;
+ }
+
+ /**
+ * Pop an error off of the error stack, static method
+ *
+ * @param string package name
+ * @return boolean
+ * @since PEAR1.5.0a1
+ */
+ function staticPop($package)
+ {
+ if ($package) {
+ if (!isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
+ return false;
+ }
+ return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->pop();
+ }
+ }
+
+ /**
+ * Determine whether there are any errors on the stack
+ * @param string|array Level name. Use to determine if any errors
+ * of level (string), or levels (array) have been pushed
+ * @return boolean
+ */
+ function hasErrors($level = false)
+ {
+ if ($level) {
+ return isset($this->_errorsByLevel[$level]);
+ }
+ return count($this->_errors);
+ }
+
+ /**
+ * Retrieve all errors since last purge
+ *
+ * @param boolean set in order to empty the error stack
+ * @param string level name, to return only errors of a particular severity
+ * @return array
+ */
+ function getErrors($purge = false, $level = false)
+ {
+ if (!$purge) {
+ if ($level) {
+ if (!isset($this->_errorsByLevel[$level])) {
+ return array();
+ } else {
+ return $this->_errorsByLevel[$level];
+ }
+ } else {
+ return $this->_errors;
+ }
+ }
+ if ($level) {
+ $ret = $this->_errorsByLevel[$level];
+ foreach ($this->_errorsByLevel[$level] as $i => $unused) {
+ // entries are references to the $_errors array
+ $this->_errorsByLevel[$level][$i] = false;
+ }
+ // array_filter removes all entries === false
+ $this->_errors = array_filter($this->_errors);
+ unset($this->_errorsByLevel[$level]);
+ return $ret;
+ }
+ $ret = $this->_errors;
+ $this->_errors = array();
+ $this->_errorsByLevel = array();
+ return $ret;
+ }
+
+ /**
+ * Determine whether there are any errors on a single error stack, or on any error stack
+ *
+ * The optional parameter can be used to test the existence of any errors without the need of
+ * singleton instantiation
+ * @param string|false Package name to check for errors
+ * @param string Level name to check for a particular severity
+ * @return boolean
+ */
+ public static function staticHasErrors($package = false, $level = false)
+ {
+ if ($package) {
+ if (!isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
+ return false;
+ }
+ return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->hasErrors($level);
+ }
+ foreach ($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] as $package => $obj) {
+ if ($obj->hasErrors($level)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Get a list of all errors since last purge, organized by package
+ * @since PEAR 1.4.0dev BC break! $level is now in the place $merge used to be
+ * @param boolean $purge Set to purge the error stack of existing errors
+ * @param string $level Set to a level name in order to retrieve only errors of a particular level
+ * @param boolean $merge Set to return a flat array, not organized by package
+ * @param array $sortfunc Function used to sort a merged array - default
+ * sorts by time, and should be good for most cases
+ *
+ * @return array
+ */
+ public static function staticGetErrors(
+ $purge = false, $level = false, $merge = false,
+ $sortfunc = array('PEAR_ErrorStack', '_sortErrors')
+ ) {
+ $ret = array();
+ if (!is_callable($sortfunc)) {
+ $sortfunc = array('PEAR_ErrorStack', '_sortErrors');
+ }
+ foreach ($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] as $package => $obj) {
+ $test = $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->getErrors($purge, $level);
+ if ($test) {
+ if ($merge) {
+ $ret = array_merge($ret, $test);
+ } else {
+ $ret[$package] = $test;
+ }
+ }
+ }
+ if ($merge) {
+ usort($ret, $sortfunc);
+ }
+ return $ret;
+ }
+
+ /**
+ * Error sorting function, sorts by time
+ * @access private
+ */
+ public static function _sortErrors($a, $b)
+ {
+ if ($a['time'] == $b['time']) {
+ return 0;
+ }
+ if ($a['time'] < $b['time']) {
+ return 1;
+ }
+ return -1;
+ }
+
+ /**
+ * Standard file/line number/function/class context callback
+ *
+ * This function uses a backtrace generated from {@link debug_backtrace()}
+ * and so will not work at all in PHP < 4.3.0. The frame should
+ * reference the frame that contains the source of the error.
+ * @return array|false either array('file' => file, 'line' => line,
+ * 'function' => function name, 'class' => class name) or
+ * if this doesn't work, then false
+ * @param unused
+ * @param integer backtrace frame.
+ * @param array Results of debug_backtrace()
+ */
+ public static function getFileLine($code, $params, $backtrace = null)
+ {
+ if ($backtrace === null) {
+ return false;
+ }
+ $frame = 0;
+ $functionframe = 1;
+ if (!isset($backtrace[1])) {
+ $functionframe = 0;
+ } else {
+ while (isset($backtrace[$functionframe]['function']) &&
+ $backtrace[$functionframe]['function'] == 'eval' &&
+ isset($backtrace[$functionframe + 1])) {
+ $functionframe++;
+ }
+ }
+ if (isset($backtrace[$frame])) {
+ if (!isset($backtrace[$frame]['file'])) {
+ $frame++;
+ }
+ $funcbacktrace = $backtrace[$functionframe];
+ $filebacktrace = $backtrace[$frame];
+ $ret = array('file' => $filebacktrace['file'],
+ 'line' => $filebacktrace['line']);
+ // rearrange for eval'd code or create function errors
+ if (strpos($filebacktrace['file'], '(') &&
+ preg_match(';^(.*?)\((\d+)\) : (.*?)\\z;', $filebacktrace['file'],
+ $matches)) {
+ $ret['file'] = $matches[1];
+ $ret['line'] = $matches[2] + 0;
+ }
+ if (isset($funcbacktrace['function']) && isset($backtrace[1])) {
+ if ($funcbacktrace['function'] != 'eval') {
+ if ($funcbacktrace['function'] == '__lambda_func') {
+ $ret['function'] = 'create_function() code';
+ } else {
+ $ret['function'] = $funcbacktrace['function'];
+ }
+ }
+ }
+ if (isset($funcbacktrace['class']) && isset($backtrace[1])) {
+ $ret['class'] = $funcbacktrace['class'];
+ }
+ return $ret;
+ }
+ return false;
+ }
+
+ /**
+ * Standard error message generation callback
+ *
+ * This method may also be called by a custom error message generator
+ * to fill in template values from the params array, simply
+ * set the third parameter to the error message template string to use
+ *
+ * The special variable %__msg% is reserved: use it only to specify
+ * where a message passed in by the user should be placed in the template,
+ * like so:
+ *
+ * Error message: %msg% - internal error
+ *
+ * If the message passed like so:
+ *
+ *
+ * $stack->push(ERROR_CODE, 'error', array(), 'server error 500');
+ *
+ *
+ * The returned error message will be "Error message: server error 500 -
+ * internal error"
+ * @param PEAR_ErrorStack
+ * @param array
+ * @param string|false Pre-generated error message template
+ *
+ * @return string
+ */
+ public static function getErrorMessage(&$stack, $err, $template = false)
+ {
+ if ($template) {
+ $mainmsg = $template;
+ } else {
+ $mainmsg = $stack->getErrorMessageTemplate($err['code']);
+ }
+ $mainmsg = str_replace('%__msg%', $err['message'], $mainmsg);
+ if (is_array($err['params']) && count($err['params'])) {
+ foreach ($err['params'] as $name => $val) {
+ if (is_array($val)) {
+ // @ is needed in case $val is a multi-dimensional array
+ $val = @implode(', ', $val);
+ }
+ if (is_object($val)) {
+ if (method_exists($val, '__toString')) {
+ $val = $val->__toString();
+ } else {
+ PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_OBJTOSTRING,
+ 'warning', array('obj' => get_class($val)),
+ 'object %obj% passed into getErrorMessage, but has no __toString() method');
+ $val = 'Object';
+ }
+ }
+ $mainmsg = str_replace('%' . $name . '%', $val, $mainmsg);
+ }
+ }
+ return $mainmsg;
+ }
+
+ /**
+ * Standard Error Message Template generator from code
+ * @return string
+ */
+ function getErrorMessageTemplate($code)
+ {
+ if (!isset($this->_errorMsgs[$code])) {
+ return '%__msg%';
+ }
+ return $this->_errorMsgs[$code];
+ }
+
+ /**
+ * Set the Error Message Template array
+ *
+ * The array format must be:
+ *
+ *
+ * Error message parameters passed into {@link push()} will be used as input
+ * for the error message. If the template is 'message %foo% was %bar%', and the
+ * parameters are array('foo' => 'one', 'bar' => 'six'), the error message returned will
+ * be 'message one was six'
+ * @return string
+ */
+ function setErrorMessageTemplate($template)
+ {
+ $this->_errorMsgs = $template;
+ }
+
+
+ /**
+ * emulate PEAR::raiseError()
+ *
+ * @return PEAR_Error
+ */
+ function raiseError()
+ {
+ require_once 'phar://go-pear.phar/' . 'PEAR.php';
+ $args = func_get_args();
+ return call_user_func_array(array('PEAR', 'raiseError'), $args);
+ }
+}
+$stack = &PEAR_ErrorStack::singleton('PEAR_ErrorStack');
+$stack->pushCallback(array('PEAR_ErrorStack', '_handleError'));
+?>
+
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * Include error handling
+ */
+//require_once 'PEAR.php';
+
+/**
+ * Which user interface class is being used.
+ * @var string class name
+ */
+$GLOBALS['_PEAR_FRONTEND_CLASS'] = 'PEAR_Frontend_CLI';
+
+/**
+ * Instance of $_PEAR_Command_uiclass.
+ * @var object
+ */
+$GLOBALS['_PEAR_FRONTEND_SINGLETON'] = null;
+
+/**
+ * Singleton-based frontend for PEAR user input/output
+ *
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Frontend extends PEAR
+{
+ /**
+ * Retrieve the frontend object
+ * @return PEAR_Frontend_CLI|PEAR_Frontend_Web|PEAR_Frontend_Gtk
+ */
+ public static function &singleton($type = null)
+ {
+ if ($type === null) {
+ if (!isset($GLOBALS['_PEAR_FRONTEND_SINGLETON'])) {
+ $a = false;
+ return $a;
+ }
+ return $GLOBALS['_PEAR_FRONTEND_SINGLETON'];
+ }
+
+ $a = PEAR_Frontend::setFrontendClass($type);
+ return $a;
+ }
+
+ /**
+ * Set the frontend class that will be used by calls to {@link singleton()}
+ *
+ * Frontends are expected to conform to the PEAR naming standard of
+ * _ => DIRECTORY_SEPARATOR (PEAR_Frontend_CLI is in PEAR/Frontend/CLI.php)
+ * @param string $uiclass full class name
+ * @return PEAR_Frontend
+ */
+ public static function &setFrontendClass($uiclass)
+ {
+ if (is_object($GLOBALS['_PEAR_FRONTEND_SINGLETON']) &&
+ is_a($GLOBALS['_PEAR_FRONTEND_SINGLETON'], $uiclass)) {
+ return $GLOBALS['_PEAR_FRONTEND_SINGLETON'];
+ }
+
+ if (!class_exists($uiclass)) {
+ $file = 'phar://go-pear.phar/' . str_replace('_', '/', $uiclass) . '.php';
+ if (PEAR_Frontend::isIncludeable($file)) {
+ include_once $file;
+ }
+ }
+
+ if (class_exists($uiclass)) {
+ $obj = new $uiclass;
+ // quick test to see if this class implements a few of the most
+ // important frontend methods
+ if (is_a($obj, 'PEAR_Frontend')) {
+ $GLOBALS['_PEAR_FRONTEND_SINGLETON'] = &$obj;
+ $GLOBALS['_PEAR_FRONTEND_CLASS'] = $uiclass;
+ return $obj;
+ }
+
+ $err = PEAR::raiseError("not a frontend class: $uiclass");
+ return $err;
+ }
+
+ $err = PEAR::raiseError("no such class: $uiclass");
+ return $err;
+ }
+
+ /**
+ * Set the frontend class that will be used by calls to {@link singleton()}
+ *
+ * Frontends are expected to be a descendant of PEAR_Frontend
+ * @param PEAR_Frontend
+ * @return PEAR_Frontend
+ */
+ public static function &setFrontendObject($uiobject)
+ {
+ if (is_object($GLOBALS['_PEAR_FRONTEND_SINGLETON']) &&
+ is_a($GLOBALS['_PEAR_FRONTEND_SINGLETON'], get_class($uiobject))) {
+ return $GLOBALS['_PEAR_FRONTEND_SINGLETON'];
+ }
+
+ if (!is_a($uiobject, 'PEAR_Frontend')) {
+ $err = PEAR::raiseError('not a valid frontend class: (' .
+ get_class($uiobject) . ')');
+ return $err;
+ }
+
+ $GLOBALS['_PEAR_FRONTEND_SINGLETON'] = &$uiobject;
+ $GLOBALS['_PEAR_FRONTEND_CLASS'] = get_class($uiobject);
+ return $uiobject;
+ }
+
+ /**
+ * @param string $path relative or absolute include path
+ * @return boolean
+ */
+ public static function isIncludeable($path)
+ {
+ if (file_exists($path) && is_readable($path)) {
+ return true;
+ }
+
+ $fp = @fopen($path, 'r', true);
+ if ($fp) {
+ fclose($fp);
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * @param PEAR_Config
+ */
+ function setConfig(&$config)
+ {
+ }
+
+ /**
+ * This can be overridden to allow session-based temporary file management
+ *
+ * By default, all files are deleted at the end of a session. The web installer
+ * needs to be able to sustain a list over many sessions in order to support
+ * user interaction with install scripts
+ */
+ function addTempFile($file)
+ {
+ $GLOBALS['_PEAR_Common_tempfiles'][] = $file;
+ }
+
+ /**
+ * Log an action
+ *
+ * @param string $msg the message to log
+ * @param boolean $append_crlf
+ * @return boolean true
+ * @abstract
+ */
+ function log($msg, $append_crlf = true)
+ {
+ }
+
+ /**
+ * Run a post-installation script
+ *
+ * @param array $scripts array of post-install scripts
+ * @abstract
+ */
+ function runPostinstallScripts(&$scripts)
+ {
+ }
+
+ /**
+ * Display human-friendly output formatted depending on the
+ * $command parameter.
+ *
+ * This should be able to handle basic output data with no command
+ * @param mixed $data data structure containing the information to display
+ * @param string $command command from which this method was called
+ * @abstract
+ */
+ function outputData($data, $command = '_default')
+ {
+ }
+
+ /**
+ * Display a modal form dialog and return the given input
+ *
+ * A frontend that requires multiple requests to retrieve and process
+ * data must take these needs into account, and implement the request
+ * handling code.
+ * @param string $command command from which this method was called
+ * @param array $prompts associative array. keys are the input field names
+ * and values are the description
+ * @param array $types array of input field types (text, password,
+ * etc.) keys have to be the same like in $prompts
+ * @param array $defaults array of default values. again keys have
+ * to be the same like in $prompts. Do not depend
+ * on a default value being set.
+ * @return array input sent by the user
+ * @abstract
+ */
+ function userDialog($command, $prompts, $types = array(), $defaults = array())
+ {
+ }
+}
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+/**
+ * base class
+ */
+require_once 'phar://go-pear.phar/' . 'PEAR/Frontend.php';
+
+/**
+ * Command-line Frontend for the PEAR Installer
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Frontend_CLI extends PEAR_Frontend
+{
+ /**
+ * What type of user interface this frontend is for.
+ * @var string
+ * @access public
+ */
+ var $type = 'CLI';
+ var $lp = ''; // line prefix
+
+ var $params = array();
+ var $term = array(
+ 'bold' => '',
+ 'normal' => '',
+ );
+
+ function __construct()
+ {
+ parent::__construct();
+ $term = getenv('TERM'); //(cox) $_ENV is empty for me in 4.1.1
+ if (function_exists('posix_isatty') && !posix_isatty(1)) {
+ // output is being redirected to a file or through a pipe
+ } elseif ($term) {
+ if (preg_match('/^(xterm|vt220|linux)/', $term)) {
+ $this->term['bold'] = sprintf("%c%c%c%c", 27, 91, 49, 109);
+ $this->term['normal'] = sprintf("%c%c%c", 27, 91, 109);
+ } elseif (preg_match('/^vt100/', $term)) {
+ $this->term['bold'] = sprintf("%c%c%c%c%c%c", 27, 91, 49, 109, 0, 0);
+ $this->term['normal'] = sprintf("%c%c%c%c%c", 27, 91, 109, 0, 0);
+ }
+ } elseif (OS_WINDOWS) {
+ // XXX add ANSI codes here
+ }
+ }
+
+ /**
+ * @param object PEAR_Error object
+ */
+ function displayError($e)
+ {
+ return $this->_displayLine($e->getMessage());
+ }
+
+ /**
+ * @param object PEAR_Error object
+ */
+ function displayFatalError($eobj)
+ {
+ $this->displayError($eobj);
+ if (class_exists('PEAR_Config')) {
+ $config = &PEAR_Config::singleton();
+ if ($config->get('verbose') > 5) {
+ if (function_exists('debug_print_backtrace')) {
+ debug_print_backtrace();
+ exit(1);
+ }
+
+ $raised = false;
+ foreach (debug_backtrace() as $i => $frame) {
+ if (!$raised) {
+ if (isset($frame['class'])
+ && strtolower($frame['class']) == 'pear'
+ && strtolower($frame['function']) == 'raiseerror'
+ ) {
+ $raised = true;
+ } else {
+ continue;
+ }
+ }
+
+ $frame['class'] = !isset($frame['class']) ? '' : $frame['class'];
+ $frame['type'] = !isset($frame['type']) ? '' : $frame['type'];
+ $frame['function'] = !isset($frame['function']) ? '' : $frame['function'];
+ $frame['line'] = !isset($frame['line']) ? '' : $frame['line'];
+ $this->_displayLine("#$i: $frame[class]$frame[type]$frame[function] $frame[line]");
+ }
+ }
+ }
+
+ exit(1);
+ }
+
+ /**
+ * Instruct the runInstallScript method to skip a paramgroup that matches the
+ * id value passed in.
+ *
+ * This method is useful for dynamically configuring which sections of a post-install script
+ * will be run based on the user's setup, which is very useful for making flexible
+ * post-install scripts without losing the cross-Frontend ability to retrieve user input
+ * @param string
+ */
+ function skipParamgroup($id)
+ {
+ $this->_skipSections[$id] = true;
+ }
+
+ function runPostinstallScripts(&$scripts)
+ {
+ foreach ($scripts as $i => $script) {
+ $this->runInstallScript($scripts[$i]->_params, $scripts[$i]->_obj);
+ }
+ }
+
+ /**
+ * @param array $xml contents of postinstallscript tag
+ * @param object $script post-installation script
+ * @param string install|upgrade
+ */
+ function runInstallScript($xml, &$script)
+ {
+ $this->_skipSections = array();
+ if (!is_array($xml) || !isset($xml['paramgroup'])) {
+ $script->run(array(), '_default');
+ return;
+ }
+
+ $completedPhases = array();
+ if (!isset($xml['paramgroup'][0])) {
+ $xml['paramgroup'] = array($xml['paramgroup']);
+ }
+
+ foreach ($xml['paramgroup'] as $group) {
+ if (isset($this->_skipSections[$group['id']])) {
+ // the post-install script chose to skip this section dynamically
+ continue;
+ }
+
+ if (isset($group['name'])) {
+ $paramname = explode('::', $group['name']);
+ if ($lastgroup['id'] != $paramname[0]) {
+ continue;
+ }
+
+ $group['name'] = $paramname[1];
+ if (!isset($answers)) {
+ return;
+ }
+
+ if (isset($answers[$group['name']])) {
+ switch ($group['conditiontype']) {
+ case '=' :
+ if ($answers[$group['name']] != $group['value']) {
+ continue 2;
+ }
+ break;
+ case '!=' :
+ if ($answers[$group['name']] == $group['value']) {
+ continue 2;
+ }
+ break;
+ case 'preg_match' :
+ if (!@preg_match('/' . $group['value'] . '/',
+ $answers[$group['name']])) {
+ continue 2;
+ }
+ break;
+ default :
+ return;
+ }
+ }
+ }
+
+ $lastgroup = $group;
+ if (isset($group['instructions'])) {
+ $this->_display($group['instructions']);
+ }
+
+ if (!isset($group['param'][0])) {
+ $group['param'] = array($group['param']);
+ }
+
+ if (isset($group['param'])) {
+ if (method_exists($script, 'postProcessPrompts')) {
+ $prompts = $script->postProcessPrompts($group['param'], $group['id']);
+ if (!is_array($prompts) || count($prompts) != count($group['param'])) {
+ $this->outputData('postinstall', 'Error: post-install script did not ' .
+ 'return proper post-processed prompts');
+ $prompts = $group['param'];
+ } else {
+ foreach ($prompts as $i => $var) {
+ if (!is_array($var) || !isset($var['prompt']) ||
+ !isset($var['name']) ||
+ ($var['name'] != $group['param'][$i]['name']) ||
+ ($var['type'] != $group['param'][$i]['type'])
+ ) {
+ $this->outputData('postinstall', 'Error: post-install script ' .
+ 'modified the variables or prompts, severe security risk. ' .
+ 'Will instead use the defaults from the package.xml');
+ $prompts = $group['param'];
+ }
+ }
+ }
+
+ $answers = $this->confirmDialog($prompts);
+ } else {
+ $answers = $this->confirmDialog($group['param']);
+ }
+ }
+
+ if ((isset($answers) && $answers) || !isset($group['param'])) {
+ if (!isset($answers)) {
+ $answers = array();
+ }
+
+ array_unshift($completedPhases, $group['id']);
+ if (!$script->run($answers, $group['id'])) {
+ $script->run($completedPhases, '_undoOnError');
+ return;
+ }
+ } else {
+ $script->run($completedPhases, '_undoOnError');
+ return;
+ }
+ }
+ }
+
+ /**
+ * Ask for user input, confirm the answers and continue until the user is satisfied
+ * @param array an array of arrays, format array('name' => 'paramname', 'prompt' =>
+ * 'text to display', 'type' => 'string'[, default => 'default value'])
+ * @return array
+ */
+ function confirmDialog($params)
+ {
+ $answers = $prompts = $types = array();
+ foreach ($params as $param) {
+ $prompts[$param['name']] = $param['prompt'];
+ $types[$param['name']] = $param['type'];
+ $answers[$param['name']] = isset($param['default']) ? $param['default'] : '';
+ }
+
+ $tried = false;
+ do {
+ if ($tried) {
+ $i = 1;
+ foreach ($answers as $var => $value) {
+ if (!strlen($value)) {
+ echo $this->bold("* Enter an answer for #" . $i . ": ({$prompts[$var]})\n");
+ }
+ $i++;
+ }
+ }
+
+ $answers = $this->userDialog('', $prompts, $types, $answers);
+ $tried = true;
+ } while (is_array($answers) && count(array_filter($answers)) != count($prompts));
+
+ return $answers;
+ }
+
+ function userDialog($command, $prompts, $types = array(), $defaults = array(), $screensize = 20)
+ {
+ if (!is_array($prompts)) {
+ return array();
+ }
+
+ $testprompts = array_keys($prompts);
+ $result = $defaults;
+
+ reset($prompts);
+ if (count($prompts) === 1) {
+ foreach ($prompts as $key => $prompt) {
+ $type = $types[$key];
+ $default = @$defaults[$key];
+ print "$prompt ";
+ if ($default) {
+ print "[$default] ";
+ }
+ print ": ";
+
+ $line = fgets(STDIN, 2048);
+ $result[$key] = ($default && trim($line) == '') ? $default : trim($line);
+ }
+
+ return $result;
+ }
+
+ $first_run = true;
+ while (true) {
+ $descLength = max(array_map('strlen', $prompts));
+ $descFormat = "%-{$descLength}s";
+ $last = count($prompts);
+
+ $i = 0;
+ foreach ($prompts as $n => $var) {
+ $res = isset($result[$n]) ? $result[$n] : null;
+ printf("%2d. $descFormat : %s\n", ++$i, $prompts[$n], $res);
+ }
+ print "\n1-$last, 'all', 'abort', or Enter to continue: ";
+
+ $tmp = trim(fgets(STDIN, 1024));
+ if (empty($tmp)) {
+ break;
+ }
+
+ if ($tmp == 'abort') {
+ return false;
+ }
+
+ if (isset($testprompts[(int)$tmp - 1])) {
+ $var = $testprompts[(int)$tmp - 1];
+ $desc = $prompts[$var];
+ $current = @$result[$var];
+ print "$desc [$current] : ";
+ $tmp = trim(fgets(STDIN, 1024));
+ if ($tmp !== '') {
+ $result[$var] = $tmp;
+ }
+ } elseif ($tmp == 'all') {
+ foreach ($prompts as $var => $desc) {
+ $current = $result[$var];
+ print "$desc [$current] : ";
+ $tmp = trim(fgets(STDIN, 1024));
+ if (trim($tmp) !== '') {
+ $result[$var] = trim($tmp);
+ }
+ }
+ }
+
+ $first_run = false;
+ }
+
+ return $result;
+ }
+
+ function userConfirm($prompt, $default = 'yes')
+ {
+ trigger_error("PEAR_Frontend_CLI::userConfirm not yet converted", E_USER_ERROR);
+ static $positives = array('y', 'yes', 'on', '1');
+ static $negatives = array('n', 'no', 'off', '0');
+ print "$this->lp$prompt [$default] : ";
+ $fp = fopen("php://stdin", "r");
+ $line = fgets($fp, 2048);
+ fclose($fp);
+ $answer = strtolower(trim($line));
+ if (empty($answer)) {
+ $answer = $default;
+ }
+ if (in_array($answer, $positives)) {
+ return true;
+ }
+ if (in_array($answer, $negatives)) {
+ return false;
+ }
+ if (in_array($default, $positives)) {
+ return true;
+ }
+ return false;
+ }
+
+ function outputData($data, $command = '_default')
+ {
+ switch ($command) {
+ case 'channel-info':
+ foreach ($data as $type => $section) {
+ if ($type == 'main') {
+ $section['data'] = array_values($section['data']);
+ }
+
+ $this->outputData($section);
+ }
+ break;
+ case 'install':
+ case 'upgrade':
+ case 'upgrade-all':
+ if (is_array($data) && isset($data['release_warnings'])) {
+ $this->_displayLine('');
+ $this->_startTable(array(
+ 'border' => false,
+ 'caption' => 'Release Warnings'
+ ));
+ $this->_tableRow(array($data['release_warnings']), null, array(1 => array('wrap' => 55)));
+ $this->_endTable();
+ $this->_displayLine('');
+ }
+
+ $this->_displayLine(is_array($data) ? $data['data'] : $data);
+ break;
+ case 'search':
+ $this->_startTable($data);
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'], array('bold' => true), array(1 => array('wrap' => 55)));
+ }
+
+ $packages = array();
+ foreach($data['data'] as $category) {
+ foreach($category as $name => $pkg) {
+ $packages[$pkg[0]] = $pkg;
+ }
+ }
+
+ $p = array_keys($packages);
+ natcasesort($p);
+ foreach ($p as $name) {
+ $this->_tableRow($packages[$name], null, array(1 => array('wrap' => 55)));
+ }
+
+ $this->_endTable();
+ break;
+ case 'list-all':
+ if (!isset($data['data'])) {
+ $this->_displayLine('No packages in channel');
+ break;
+ }
+
+ $this->_startTable($data);
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'], array('bold' => true), array(1 => array('wrap' => 55)));
+ }
+
+ $packages = array();
+ foreach($data['data'] as $category) {
+ foreach($category as $name => $pkg) {
+ $packages[$pkg[0]] = $pkg;
+ }
+ }
+
+ $p = array_keys($packages);
+ natcasesort($p);
+ foreach ($p as $name) {
+ $pkg = $packages[$name];
+ unset($pkg[4], $pkg[5]);
+ $this->_tableRow($pkg, null, array(1 => array('wrap' => 55)));
+ }
+
+ $this->_endTable();
+ break;
+ case 'config-show':
+ $data['border'] = false;
+ $opts = array(
+ 0 => array('wrap' => 30),
+ 1 => array('wrap' => 20),
+ 2 => array('wrap' => 35)
+ );
+
+ $this->_startTable($data);
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'], array('bold' => true), $opts);
+ }
+
+ foreach ($data['data'] as $group) {
+ foreach ($group as $value) {
+ if ($value[2] == '') {
+ $value[2] = "";
+ }
+
+ $this->_tableRow($value, null, $opts);
+ }
+ }
+
+ $this->_endTable();
+ break;
+ case 'remote-info':
+ $d = $data;
+ $data = array(
+ 'caption' => 'Package details:',
+ 'border' => false,
+ 'data' => array(
+ array("Latest", $data['stable']),
+ array("Installed", $data['installed']),
+ array("Package", $data['name']),
+ array("License", $data['license']),
+ array("Category", $data['category']),
+ array("Summary", $data['summary']),
+ array("Description", $data['description']),
+ ),
+ );
+
+ if (isset($d['deprecated']) && $d['deprecated']) {
+ $conf = &PEAR_Config::singleton();
+ $reg = $conf->getRegistry();
+ $name = $reg->parsedPackageNameToString($d['deprecated'], true);
+ $data['data'][] = array('Deprecated! use', $name);
+ }
+ default: {
+ if (is_array($data)) {
+ $this->_startTable($data);
+ $count = count($data['data'][0]);
+ if ($count == 2) {
+ $opts = array(0 => array('wrap' => 25),
+ 1 => array('wrap' => 48)
+ );
+ } elseif ($count == 3) {
+ $opts = array(0 => array('wrap' => 30),
+ 1 => array('wrap' => 20),
+ 2 => array('wrap' => 35)
+ );
+ } else {
+ $opts = null;
+ }
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'],
+ array('bold' => true),
+ $opts);
+ }
+
+ if (is_array($data['data'])) {
+ foreach($data['data'] as $row) {
+ $this->_tableRow($row, null, $opts);
+ }
+ } else {
+ $this->_tableRow(array($data['data']), null, $opts);
+ }
+ $this->_endTable();
+ } else {
+ $this->_displayLine($data);
+ }
+ }
+ }
+ }
+
+ function log($text, $append_crlf = true)
+ {
+ if ($append_crlf) {
+ return $this->_displayLine($text);
+ }
+
+ return $this->_display($text);
+ }
+
+ function bold($text)
+ {
+ if (empty($this->term['bold'])) {
+ return strtoupper($text);
+ }
+
+ return $this->term['bold'] . $text . $this->term['normal'];
+ }
+
+ function _displayHeading($title)
+ {
+ print $this->lp.$this->bold($title)."\n";
+ print $this->lp.str_repeat("=", strlen($title))."\n";
+ }
+
+ function _startTable($params = array())
+ {
+ $params['table_data'] = array();
+ $params['widest'] = array(); // indexed by column
+ $params['highest'] = array(); // indexed by row
+ $params['ncols'] = 0;
+ $this->params = $params;
+ }
+
+ function _tableRow($columns, $rowparams = array(), $colparams = array())
+ {
+ $highest = 1;
+ for ($i = 0; $i < count($columns); $i++) {
+ $col = &$columns[$i];
+ if (isset($colparams[$i]) && !empty($colparams[$i]['wrap'])) {
+ $col = wordwrap($col, $colparams[$i]['wrap']);
+ }
+
+ if (strpos($col, "\n") !== false) {
+ $multiline = explode("\n", $col);
+ $w = 0;
+ foreach ($multiline as $n => $line) {
+ $len = strlen($line);
+ if ($len > $w) {
+ $w = $len;
+ }
+ }
+ $lines = count($multiline);
+ } else {
+ $w = strlen($col);
+ }
+
+ if (isset($this->params['widest'][$i])) {
+ if ($w > $this->params['widest'][$i]) {
+ $this->params['widest'][$i] = $w;
+ }
+ } else {
+ $this->params['widest'][$i] = $w;
+ }
+
+ $tmp = count_chars($columns[$i], 1);
+ // handle unix, mac and windows formats
+ $lines = (isset($tmp[10]) ? $tmp[10] : (isset($tmp[13]) ? $tmp[13] : 0)) + 1;
+ if ($lines > $highest) {
+ $highest = $lines;
+ }
+ }
+
+ if (count($columns) > $this->params['ncols']) {
+ $this->params['ncols'] = count($columns);
+ }
+
+ $new_row = array(
+ 'data' => $columns,
+ 'height' => $highest,
+ 'rowparams' => $rowparams,
+ 'colparams' => $colparams,
+ );
+ $this->params['table_data'][] = $new_row;
+ }
+
+ function _endTable()
+ {
+ extract($this->params);
+ if (!empty($caption)) {
+ $this->_displayHeading($caption);
+ }
+
+ if (count($table_data) === 0) {
+ return;
+ }
+
+ if (!isset($width)) {
+ $width = $widest;
+ } else {
+ for ($i = 0; $i < $ncols; $i++) {
+ if (!isset($width[$i])) {
+ $width[$i] = $widest[$i];
+ }
+ }
+ }
+
+ $border = false;
+ if (empty($border)) {
+ $cellstart = '';
+ $cellend = ' ';
+ $rowend = '';
+ $padrowend = false;
+ $borderline = '';
+ } else {
+ $cellstart = '| ';
+ $cellend = ' ';
+ $rowend = '|';
+ $padrowend = true;
+ $borderline = '+';
+ foreach ($width as $w) {
+ $borderline .= str_repeat('-', $w + strlen($cellstart) + strlen($cellend) - 1);
+ $borderline .= '+';
+ }
+ }
+
+ if ($borderline) {
+ $this->_displayLine($borderline);
+ }
+
+ for ($i = 0; $i < count($table_data); $i++) {
+ extract($table_data[$i]);
+ if (!is_array($rowparams)) {
+ $rowparams = array();
+ }
+
+ if (!is_array($colparams)) {
+ $colparams = array();
+ }
+
+ $rowlines = array();
+ if ($height > 1) {
+ for ($c = 0; $c < count($data); $c++) {
+ $rowlines[$c] = preg_split('/(\r?\n|\r)/', $data[$c]);
+ if (count($rowlines[$c]) < $height) {
+ $rowlines[$c] = array_pad($rowlines[$c], $height, '');
+ }
+ }
+ } else {
+ for ($c = 0; $c < count($data); $c++) {
+ $rowlines[$c] = array($data[$c]);
+ }
+ }
+
+ for ($r = 0; $r < $height; $r++) {
+ $rowtext = '';
+ for ($c = 0; $c < count($data); $c++) {
+ if (isset($colparams[$c])) {
+ $attribs = array_merge($rowparams, $colparams);
+ } else {
+ $attribs = $rowparams;
+ }
+
+ $w = isset($width[$c]) ? $width[$c] : 0;
+ //$cell = $data[$c];
+ $cell = $rowlines[$c][$r];
+ $l = strlen($cell);
+ if ($l > $w) {
+ $cell = substr($cell, 0, $w);
+ }
+
+ if (isset($attribs['bold'])) {
+ $cell = $this->bold($cell);
+ }
+
+ if ($l < $w) {
+ // not using str_pad here because we may
+ // add bold escape characters to $cell
+ $cell .= str_repeat(' ', $w - $l);
+ }
+
+ $rowtext .= $cellstart . $cell . $cellend;
+ }
+
+ if (!$border) {
+ $rowtext = rtrim($rowtext);
+ }
+
+ $rowtext .= $rowend;
+ $this->_displayLine($rowtext);
+ }
+ }
+
+ if ($borderline) {
+ $this->_displayLine($borderline);
+ }
+ }
+
+ function _displayLine($text)
+ {
+ print "$this->lp$text\n";
+ }
+
+ function _display($text)
+ {
+ print $text;
+ }
+}
+package.xml 0000664 0001750 0001750 00000032572 12553124254 013017 0 ustar michiel michiel
+
+ Archive_Tar
+ pear.php.net
+ Tar file management class
+ This class provides handling of tar files in PHP.
+It supports creating, listing, extracting and adding to tar files.
+Gzip support is available if PHP has the zlib extension built-in or
+loaded. Bz2 compression is also supported with the bz2 extension loaded.
+
+ Vincent Blavet
+ vblavet
+ vincent@phpconcept.net
+ no
+
+
+ Greg Beaver
+ cellog
+ greg@chiaraquartet.net
+ no
+
+
+ Michiel Rook
+ mrook
+ mrook@php.net
+ yes
+
+
+ Stig Bakken
+ ssb
+ stig@php.net
+ no
+
+ 2015-07-20
+
+
+ 1.4.0
+ 1.4.0
+
+
+ stable
+ stable
+
+ New BSD License
+
+* Add support for PHP 7
+* Drop support for PHP 4
+* Add visibility declarations to methods and properties
+
+
+
+
+
+
+
+
+ PEAR
+ pear.php.net
+ 1.8.0
+ 1.10.10
+
+
+
+
+ 5.2.0
+
+
+ 1.9.0
+
+
+
+
+
+
+
+ 1.3.16
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2015-04-14
+ New BSD License
+
+* Fix Bug #20514: invalid package.xml; not installable with pyrus [mrook]
+
+
+
+
+ 1.3.15
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2015-03-05
+ New BSD License
+
+* Fixes composer.json parse error
+
+
+
+
+ 1.3.14
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2015-02-26
+ New BSD License
+
+* Fix Bug #18505: Possible incorrect handling of file names in TAR [mrook]
+
+
+
+
+ 1.3.13
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2014-09-02
+ New BSD
+ License
+
+* Fix Bug #20382: gzopen fix [mrook]
+
+
+
+
+ 1.3.12
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2014-08-04
+ New BSD
+ License
+
+* Fix Bug #19964: Memory leaking in Archive_Tar [mrook]
+ * Fix Bug #20246: Broken with php 5.5.9 [mrook]
+ * Fix Bug #20275: "pax_global_header" looks like a regular file
+ * [mrook]
+ * Implement Feature #19827: pass filename to _addFile function - downstream
+ * patch [mrook]
+ * Implement Feature #20132: Add custom mode/uid/gid to addString() [mrook]
+
+
+
+
+ 1.3.11
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2013-02-09
+ New BSD
+ License
+
+* Fix Bug #19746: Broken with PHP 5.5 [mrook]
+ * Implement Feature #11258: Custom date/time in files added on-the-fly
+ * [mrook]
+
+
+
+
+ 1.3.10
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2012-04-10
+ New BSD
+ License
+
+* Fix Bug #13361: Unable to add() some files (ex. mp3) [mrook]
+ * Fix Bug #19330: Class creates incorrect (non-readable) tar.gz file
+ * [mrook]
+
+
+
+
+ 1.3.9
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2012-02-27
+ New BSD License
+
+* Fix Bug #16759: No error thrown from missing PHP zlib functions [mrook]
+ * Fix Bug #18877: Incorrect handling of backslashes in filenames on Linux [mrook]
+ * Fix Bug #19085: Error while packaging [mrook]
+ * Fix Bug #19289: Invalid tar file generated [mrook]
+
+
+
+
+ 1.3.8
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2011-10-14
+ New BSD License
+
+* Fix Bug #17853: Test failure: dirtraversal.phpt [mrook]
+ * Fix Bug #18512: dead links are not saved in tar file [mrook]
+ * Fix Bug #18702: Unpacks incorrectly on long file names using header prefix [mrook]
+ * Implement Feature #10145: Patch to return a Pear Error Object on failure [mrook]
+ * Implement Feature #17491: Option to preserve permissions [mrook]
+ * Implement Feature #17813: Prevent PHP notice when extracting corrupted archive [mrook]
+
+
+
+
+ 1.3.7
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2010-04-26
+ New BSD License
+
+PEAR compatibility update
+
+
+
+
+ 1.3.6
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2010-03-09
+ New BSD License
+
+* Fix Bug #16963: extractList can't extract zipped files from big tar [mrook]
+ * Implement Feature #4013: Ignoring files and directories on creating an archive. [mrook]
+
+
+
+
+ 1.3.5
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2009-12-31
+ New BSD License
+
+* Fix Bug #16958: Update 'compatible' tag in package.xml [mrook]
+
+
+
+
+ 1.3.4
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2009-12-30
+ New BSD License
+
+* Fix Bug #11871: wrong result of ::listContent() if filename begins or ends with space [mrook]
+ * Fix Bug #12462: invalid tar magic [mrook]
+ * Fix Bug #13918: Long filenames may get up to 511 0x00 bytes appended on read [mrook]
+ * Fix Bug #16202: Bogus modification times [mrook]
+ * Implement Feature #16212: Die is not exception [mrook]
+
+
+
+
+ 1.3.3
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2009-03-27
+ New BSD License
+
+Change the license to New BSD license
+
+ minor bugfix release
+ * fix Bug #9921 compression with bzip2 fails [cellog]
+ * fix Bug #11594 _readLongHeader leaves 0 bytes in filename [jamessas]
+ * fix Bug #11769 Incorrect symlink handing [fajar99]
+
+
+
+
+ 1.3.2
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2007-01-03
+ PHP License
+
+Correct Bug #4016
+Remove duplicate remove error display with '@'
+Correct Bug #3909 : Check existence of OS_WINDOWS constant
+Correct Bug #5452 fix for "lone zero block" when untarring packages
+Change filemode (from pear-core/Archive/Tar.php v.1.21)
+Correct Bug #6486 Can not extract symlinks
+Correct Bug #6933 Archive_Tar (Tar file management class) Directory traversal
+Correct Bug #8114 Files added on-the-fly not storing date
+Correct Bug #9352 Bug on _dirCheck function over nfs path
+
+
+
+
+ 1.3.1
+ 1.3.1
+
+
+ stable
+ stable
+
+ 2005-03-17
+ PHP License
+
+Correct Bug #3855
+
+
+
+
+ 1.3.0
+ 1.3.0
+
+
+ stable
+ stable
+
+ 2005-03-06
+ PHP License
+
+Bugs correction (2475, 2488, 2135, 2176)
+
+
+
+
+ 1.2
+ 1.2
+
+
+ stable
+ stable
+
+ 2004-05-08
+ PHP License
+
+Add support for other separator than the space char and bug
+ correction
+
+
+
+
+ 1.1
+ 1.1
+
+
+ stable
+ stable
+
+ 2003-05-28
+ PHP License
+
+* Add support for BZ2 compression
+* Add support for add and extract without using temporary files : methods addString() and extractInString()
+
+
+
+
+ 1.0
+ 1.0
+
+
+ stable
+ stable
+
+ 2003-01-24
+ PHP License
+
+Change status to stable
+
+
+
+
+ 0.10-b1
+ 0.10-b1
+
+
+ beta
+ beta
+
+ 2003-01-08
+ PHP License
+
+Add support for long filenames (greater than 99 characters)
+
+
+
+
+ 0.9
+ 0.9
+
+
+ stable
+ stable
+
+ 2002-05-27
+ PHP License
+
+Auto-detect gzip'ed files
+
+
+
+
+ 0.4
+ 0.4
+
+
+ stable
+ stable
+
+ 2002-05-20
+ PHP License
+
+Windows bugfix: use forward slashes inside archives
+
+
+
+
+ 0.2
+ 0.2
+
+
+ stable
+ stable
+
+ 2002-02-18
+ PHP License
+
+From initial commit to stable
+
+
+
+
+ 0.3
+ 0.3
+
+
+ stable
+ stable
+
+ 2002-04-13
+ PHP License
+
+Windows bugfix: used wrong directory separators
+
+
+
+
+ Archive_Tar-1.4.0/Archive/Tar.php 0000664 0001750 0001750 00000240260 12553124254 016342 0 ustar michiel michiel
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @category File_Formats
+ * @package Archive_Tar
+ * @author Vincent Blavet
+ * @copyright 1997-2010 The Authors
+ * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version CVS: $Id$
+ * @link http://pear.php.net/package/Archive_Tar
+ */
+
+require_once 'PEAR.php';
+
+define('ARCHIVE_TAR_ATT_SEPARATOR', 90001);
+define('ARCHIVE_TAR_END_BLOCK', pack("a512", ''));
+
+if (!function_exists('gzopen') && function_exists('gzopen64')) {
+ function gzopen($filename, $mode, $use_include_path = 0)
+ {
+ return gzopen64($filename, $mode, $use_include_path);
+ }
+}
+
+if (!function_exists('gztell') && function_exists('gztell64')) {
+ function gztell($zp)
+ {
+ return gztell64($zp);
+ }
+}
+
+if (!function_exists('gzseek') && function_exists('gzseek64')) {
+ function gzseek($zp, $offset, $whence = SEEK_SET)
+ {
+ return gzseek64($zp, $offset, $whence);
+ }
+}
+
+/**
+ * Creates a (compressed) Tar archive
+ *
+ * @package Archive_Tar
+ * @author Vincent Blavet
+ * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
+ * @version $Revision$
+ */
+class Archive_Tar extends PEAR
+{
+ /**
+ * @var string Name of the Tar
+ */
+ public $_tarname = '';
+
+ /**
+ * @var boolean if true, the Tar file will be gzipped
+ */
+ public $_compress = false;
+
+ /**
+ * @var string Type of compression : 'none', 'gz', 'bz2' or 'lzma2'
+ */
+ public $_compress_type = 'none';
+
+ /**
+ * @var string Explode separator
+ */
+ public $_separator = ' ';
+
+ /**
+ * @var file descriptor
+ */
+ public $_file = 0;
+
+ /**
+ * @var string Local Tar name of a remote Tar (http:// or ftp://)
+ */
+ public $_temp_tarname = '';
+
+ /**
+ * @var string regular expression for ignoring files or directories
+ */
+ public $_ignore_regexp = '';
+
+ /**
+ * @var object PEAR_Error object
+ */
+ public $error_object = null;
+
+ /**
+ * Archive_Tar Class constructor. This flavour of the constructor only
+ * declare a new Archive_Tar object, identifying it by the name of the
+ * tar file.
+ * If the compress argument is set the tar will be read or created as a
+ * gzip or bz2 compressed TAR file.
+ *
+ * @param string $p_tarname The name of the tar archive to create
+ * @param string $p_compress can be null, 'gz', 'bz2' or 'lzma2'. This
+ * parameter indicates if gzip, bz2 or lzma2 compression
+ * is required. For compatibility reason the
+ * boolean value 'true' means 'gz'.
+ *
+ * @return bool
+ */
+ public function __construct($p_tarname, $p_compress = null)
+ {
+ parent::__construct();
+
+ $this->_compress = false;
+ $this->_compress_type = 'none';
+ if (($p_compress === null) || ($p_compress == '')) {
+ if (@file_exists($p_tarname)) {
+ if ($fp = @fopen($p_tarname, "rb")) {
+ // look for gzip magic cookie
+ $data = fread($fp, 2);
+ fclose($fp);
+ if ($data == "\37\213") {
+ $this->_compress = true;
+ $this->_compress_type = 'gz';
+ // No sure it's enought for a magic code ....
+ } elseif ($data == "BZ") {
+ $this->_compress = true;
+ $this->_compress_type = 'bz2';
+ } elseif (file_get_contents($p_tarname, false, null, 1, 4) == '7zXZ') {
+ $this->_compress = true;
+ $this->_compress_type = 'lzma2';
+ }
+ }
+ } else {
+ // probably a remote file or some file accessible
+ // through a stream interface
+ if (substr($p_tarname, -2) == 'gz') {
+ $this->_compress = true;
+ $this->_compress_type = 'gz';
+ } elseif ((substr($p_tarname, -3) == 'bz2') ||
+ (substr($p_tarname, -2) == 'bz')
+ ) {
+ $this->_compress = true;
+ $this->_compress_type = 'bz2';
+ } else {
+ if (substr($p_tarname, -2) == 'xz') {
+ $this->_compress = true;
+ $this->_compress_type = 'lzma2';
+ }
+ }
+ }
+ } else {
+ if (($p_compress === true) || ($p_compress == 'gz')) {
+ $this->_compress = true;
+ $this->_compress_type = 'gz';
+ } else {
+ if ($p_compress == 'bz2') {
+ $this->_compress = true;
+ $this->_compress_type = 'bz2';
+ } else {
+ if ($p_compress == 'lzma2') {
+ $this->_compress = true;
+ $this->_compress_type = 'lzma2';
+ } else {
+ $this->_error(
+ "Unsupported compression type '$p_compress'\n" .
+ "Supported types are 'gz', 'bz2' and 'lzma2'.\n"
+ );
+ return false;
+ }
+ }
+ }
+ }
+ $this->_tarname = $p_tarname;
+ if ($this->_compress) { // assert zlib or bz2 or xz extension support
+ if ($this->_compress_type == 'gz') {
+ $extname = 'zlib';
+ } else {
+ if ($this->_compress_type == 'bz2') {
+ $extname = 'bz2';
+ } else {
+ if ($this->_compress_type == 'lzma2') {
+ $extname = 'xz';
+ }
+ }
+ }
+
+ if (!extension_loaded($extname)) {
+ PEAR::loadExtension($extname);
+ }
+ if (!extension_loaded($extname)) {
+ $this->_error(
+ "The extension '$extname' couldn't be found.\n" .
+ "Please make sure your version of PHP was built " .
+ "with '$extname' support.\n"
+ );
+ return false;
+ }
+ }
+ }
+
+ public function __destruct()
+ {
+ $this->_close();
+ // ----- Look for a local copy to delete
+ if ($this->_temp_tarname != '') {
+ @unlink($this->_temp_tarname);
+ }
+ }
+
+ /**
+ * This method creates the archive file and add the files / directories
+ * that are listed in $p_filelist.
+ * If a file with the same name exist and is writable, it is replaced
+ * by the new tar.
+ * The method return false and a PEAR error text.
+ * The $p_filelist parameter can be an array of string, each string
+ * representing a filename or a directory name with their path if
+ * needed. It can also be a single string with names separated by a
+ * single blank.
+ * For each directory added in the archive, the files and
+ * sub-directories are also added.
+ * See also createModify() method for more details.
+ *
+ * @param array $p_filelist An array of filenames and directory names, or a
+ * single string with names separated by a single
+ * blank space.
+ *
+ * @return true on success, false on error.
+ * @see createModify()
+ */
+ public function create($p_filelist)
+ {
+ return $this->createModify($p_filelist, '', '');
+ }
+
+ /**
+ * This method add the files / directories that are listed in $p_filelist in
+ * the archive. If the archive does not exist it is created.
+ * The method return false and a PEAR error text.
+ * The files and directories listed are only added at the end of the archive,
+ * even if a file with the same name is already archived.
+ * See also createModify() method for more details.
+ *
+ * @param array $p_filelist An array of filenames and directory names, or a
+ * single string with names separated by a single
+ * blank space.
+ *
+ * @return true on success, false on error.
+ * @see createModify()
+ * @access public
+ */
+ public function add($p_filelist)
+ {
+ return $this->addModify($p_filelist, '', '');
+ }
+
+ /**
+ * @param string $p_path
+ * @param bool $p_preserve
+ * @return bool
+ */
+ public function extract($p_path = '', $p_preserve = false)
+ {
+ return $this->extractModify($p_path, '', $p_preserve);
+ }
+
+ /**
+ * @return array|int
+ */
+ public function listContent()
+ {
+ $v_list_detail = array();
+
+ if ($this->_openRead()) {
+ if (!$this->_extractList('', $v_list_detail, "list", '', '')) {
+ unset($v_list_detail);
+ $v_list_detail = 0;
+ }
+ $this->_close();
+ }
+
+ return $v_list_detail;
+ }
+
+ /**
+ * This method creates the archive file and add the files / directories
+ * that are listed in $p_filelist.
+ * If the file already exists and is writable, it is replaced by the
+ * new tar. It is a create and not an add. If the file exists and is
+ * read-only or is a directory it is not replaced. The method return
+ * false and a PEAR error text.
+ * The $p_filelist parameter can be an array of string, each string
+ * representing a filename or a directory name with their path if
+ * needed. It can also be a single string with names separated by a
+ * single blank.
+ * The path indicated in $p_remove_dir will be removed from the
+ * memorized path of each file / directory listed when this path
+ * exists. By default nothing is removed (empty path '')
+ * The path indicated in $p_add_dir will be added at the beginning of
+ * the memorized path of each file / directory listed. However it can
+ * be set to empty ''. The adding of a path is done after the removing
+ * of path.
+ * The path add/remove ability enables the user to prepare an archive
+ * for extraction in a different path than the origin files are.
+ * See also addModify() method for file adding properties.
+ *
+ * @param array $p_filelist An array of filenames and directory names,
+ * or a single string with names separated by
+ * a single blank space.
+ * @param string $p_add_dir A string which contains a path to be added
+ * to the memorized path of each element in
+ * the list.
+ * @param string $p_remove_dir A string which contains a path to be
+ * removed from the memorized path of each
+ * element in the list, when relevant.
+ *
+ * @return boolean true on success, false on error.
+ * @see addModify()
+ */
+ public function createModify($p_filelist, $p_add_dir, $p_remove_dir = '')
+ {
+ $v_result = true;
+
+ if (!$this->_openWrite()) {
+ return false;
+ }
+
+ if ($p_filelist != '') {
+ if (is_array($p_filelist)) {
+ $v_list = $p_filelist;
+ } elseif (is_string($p_filelist)) {
+ $v_list = explode($this->_separator, $p_filelist);
+ } else {
+ $this->_cleanFile();
+ $this->_error('Invalid file list');
+ return false;
+ }
+
+ $v_result = $this->_addList($v_list, $p_add_dir, $p_remove_dir);
+ }
+
+ if ($v_result) {
+ $this->_writeFooter();
+ $this->_close();
+ } else {
+ $this->_cleanFile();
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * This method add the files / directories listed in $p_filelist at the
+ * end of the existing archive. If the archive does not yet exists it
+ * is created.
+ * The $p_filelist parameter can be an array of string, each string
+ * representing a filename or a directory name with their path if
+ * needed. It can also be a single string with names separated by a
+ * single blank.
+ * The path indicated in $p_remove_dir will be removed from the
+ * memorized path of each file / directory listed when this path
+ * exists. By default nothing is removed (empty path '')
+ * The path indicated in $p_add_dir will be added at the beginning of
+ * the memorized path of each file / directory listed. However it can
+ * be set to empty ''. The adding of a path is done after the removing
+ * of path.
+ * The path add/remove ability enables the user to prepare an archive
+ * for extraction in a different path than the origin files are.
+ * If a file/dir is already in the archive it will only be added at the
+ * end of the archive. There is no update of the existing archived
+ * file/dir. However while extracting the archive, the last file will
+ * replace the first one. This results in a none optimization of the
+ * archive size.
+ * If a file/dir does not exist the file/dir is ignored. However an
+ * error text is send to PEAR error.
+ * If a file/dir is not readable the file/dir is ignored. However an
+ * error text is send to PEAR error.
+ *
+ * @param array $p_filelist An array of filenames and directory
+ * names, or a single string with names
+ * separated by a single blank space.
+ * @param string $p_add_dir A string which contains a path to be
+ * added to the memorized path of each
+ * element in the list.
+ * @param string $p_remove_dir A string which contains a path to be
+ * removed from the memorized path of
+ * each element in the list, when
+ * relevant.
+ *
+ * @return true on success, false on error.
+ */
+ public function addModify($p_filelist, $p_add_dir, $p_remove_dir = '')
+ {
+ $v_result = true;
+
+ if (!$this->_isArchive()) {
+ $v_result = $this->createModify(
+ $p_filelist,
+ $p_add_dir,
+ $p_remove_dir
+ );
+ } else {
+ if (is_array($p_filelist)) {
+ $v_list = $p_filelist;
+ } elseif (is_string($p_filelist)) {
+ $v_list = explode($this->_separator, $p_filelist);
+ } else {
+ $this->_error('Invalid file list');
+ return false;
+ }
+
+ $v_result = $this->_append($v_list, $p_add_dir, $p_remove_dir);
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * This method add a single string as a file at the
+ * end of the existing archive. If the archive does not yet exists it
+ * is created.
+ *
+ * @param string $p_filename A string which contains the full
+ * filename path that will be associated
+ * with the string.
+ * @param string $p_string The content of the file added in
+ * the archive.
+ * @param bool|int $p_datetime A custom date/time (unix timestamp)
+ * for the file (optional).
+ * @param array $p_params An array of optional params:
+ * stamp => the datetime (replaces
+ * datetime above if it exists)
+ * mode => the permissions on the
+ * file (600 by default)
+ * type => is this a link? See the
+ * tar specification for details.
+ * (default = regular file)
+ * uid => the user ID of the file
+ * (default = 0 = root)
+ * gid => the group ID of the file
+ * (default = 0 = root)
+ *
+ * @return true on success, false on error.
+ */
+ public function addString($p_filename, $p_string, $p_datetime = false, $p_params = array())
+ {
+ $p_stamp = @$p_params["stamp"] ? $p_params["stamp"] : ($p_datetime ? $p_datetime : time());
+ $p_mode = @$p_params["mode"] ? $p_params["mode"] : 0600;
+ $p_type = @$p_params["type"] ? $p_params["type"] : "";
+ $p_uid = @$p_params["uid"] ? $p_params["uid"] : "";
+ $p_gid = @$p_params["gid"] ? $p_params["gid"] : "";
+ $v_result = true;
+
+ if (!$this->_isArchive()) {
+ if (!$this->_openWrite()) {
+ return false;
+ }
+ $this->_close();
+ }
+
+ if (!$this->_openAppend()) {
+ return false;
+ }
+
+ // Need to check the get back to the temporary file ? ....
+ $v_result = $this->_addString($p_filename, $p_string, $p_datetime, $p_params);
+
+ $this->_writeFooter();
+
+ $this->_close();
+
+ return $v_result;
+ }
+
+ /**
+ * This method extract all the content of the archive in the directory
+ * indicated by $p_path. When relevant the memorized path of the
+ * files/dir can be modified by removing the $p_remove_path path at the
+ * beginning of the file/dir path.
+ * While extracting a file, if the directory path does not exists it is
+ * created.
+ * While extracting a file, if the file already exists it is replaced
+ * without looking for last modification date.
+ * While extracting a file, if the file already exists and is write
+ * protected, the extraction is aborted.
+ * While extracting a file, if a directory with the same name already
+ * exists, the extraction is aborted.
+ * While extracting a directory, if a file with the same name already
+ * exists, the extraction is aborted.
+ * While extracting a file/directory if the destination directory exist
+ * and is write protected, or does not exist but can not be created,
+ * the extraction is aborted.
+ * If after extraction an extracted file does not show the correct
+ * stored file size, the extraction is aborted.
+ * When the extraction is aborted, a PEAR error text is set and false
+ * is returned. However the result can be a partial extraction that may
+ * need to be manually cleaned.
+ *
+ * @param string $p_path The path of the directory where the
+ * files/dir need to by extracted.
+ * @param string $p_remove_path Part of the memorized path that can be
+ * removed if present at the beginning of
+ * the file/dir path.
+ * @param boolean $p_preserve Preserve user/group ownership of files
+ *
+ * @return boolean true on success, false on error.
+ * @see extractList()
+ */
+ public function extractModify($p_path, $p_remove_path, $p_preserve = false)
+ {
+ $v_result = true;
+ $v_list_detail = array();
+
+ if ($v_result = $this->_openRead()) {
+ $v_result = $this->_extractList(
+ $p_path,
+ $v_list_detail,
+ "complete",
+ 0,
+ $p_remove_path,
+ $p_preserve
+ );
+ $this->_close();
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * This method extract from the archive one file identified by $p_filename.
+ * The return value is a string with the file content, or NULL on error.
+ *
+ * @param string $p_filename The path of the file to extract in a string.
+ *
+ * @return a string with the file content or NULL.
+ */
+ public function extractInString($p_filename)
+ {
+ if ($this->_openRead()) {
+ $v_result = $this->_extractInString($p_filename);
+ $this->_close();
+ } else {
+ $v_result = null;
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * This method extract from the archive only the files indicated in the
+ * $p_filelist. These files are extracted in the current directory or
+ * in the directory indicated by the optional $p_path parameter.
+ * If indicated the $p_remove_path can be used in the same way as it is
+ * used in extractModify() method.
+ *
+ * @param array $p_filelist An array of filenames and directory names,
+ * or a single string with names separated
+ * by a single blank space.
+ * @param string $p_path The path of the directory where the
+ * files/dir need to by extracted.
+ * @param string $p_remove_path Part of the memorized path that can be
+ * removed if present at the beginning of
+ * the file/dir path.
+ * @param boolean $p_preserve Preserve user/group ownership of files
+ *
+ * @return true on success, false on error.
+ * @see extractModify()
+ */
+ public function extractList($p_filelist, $p_path = '', $p_remove_path = '', $p_preserve = false)
+ {
+ $v_result = true;
+ $v_list_detail = array();
+
+ if (is_array($p_filelist)) {
+ $v_list = $p_filelist;
+ } elseif (is_string($p_filelist)) {
+ $v_list = explode($this->_separator, $p_filelist);
+ } else {
+ $this->_error('Invalid string list');
+ return false;
+ }
+
+ if ($v_result = $this->_openRead()) {
+ $v_result = $this->_extractList(
+ $p_path,
+ $v_list_detail,
+ "partial",
+ $v_list,
+ $p_remove_path,
+ $p_preserve
+ );
+ $this->_close();
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * This method set specific attributes of the archive. It uses a variable
+ * list of parameters, in the format attribute code + attribute values :
+ * $arch->setAttribute(ARCHIVE_TAR_ATT_SEPARATOR, ',');
+ *
+ * @return true on success, false on error.
+ */
+ public function setAttribute()
+ {
+ $v_result = true;
+
+ // ----- Get the number of variable list of arguments
+ if (($v_size = func_num_args()) == 0) {
+ return true;
+ }
+
+ // ----- Get the arguments
+ $v_att_list = & func_get_args();
+
+ // ----- Read the attributes
+ $i = 0;
+ while ($i < $v_size) {
+
+ // ----- Look for next option
+ switch ($v_att_list[$i]) {
+ // ----- Look for options that request a string value
+ case ARCHIVE_TAR_ATT_SEPARATOR :
+ // ----- Check the number of parameters
+ if (($i + 1) >= $v_size) {
+ $this->_error(
+ 'Invalid number of parameters for '
+ . 'attribute ARCHIVE_TAR_ATT_SEPARATOR'
+ );
+ return false;
+ }
+
+ // ----- Get the value
+ $this->_separator = $v_att_list[$i + 1];
+ $i++;
+ break;
+
+ default :
+ $this->_error('Unknown attribute code ' . $v_att_list[$i] . '');
+ return false;
+ }
+
+ // ----- Next attribute
+ $i++;
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * This method sets the regular expression for ignoring files and directories
+ * at import, for example:
+ * $arch->setIgnoreRegexp("#CVS|\.svn#");
+ *
+ * @param string $regexp regular expression defining which files or directories to ignore
+ */
+ public function setIgnoreRegexp($regexp)
+ {
+ $this->_ignore_regexp = $regexp;
+ }
+
+ /**
+ * This method sets the regular expression for ignoring all files and directories
+ * matching the filenames in the array list at import, for example:
+ * $arch->setIgnoreList(array('CVS', '.svn', 'bin/tool'));
+ *
+ * @param array $list a list of file or directory names to ignore
+ *
+ * @access public
+ */
+ public function setIgnoreList($list)
+ {
+ $regexp = str_replace(array('#', '.', '^', '$'), array('\#', '\.', '\^', '\$'), $list);
+ $regexp = '#/' . join('$|/', $list) . '#';
+ $this->setIgnoreRegexp($regexp);
+ }
+
+ /**
+ * @param string $p_message
+ */
+ public function _error($p_message)
+ {
+ $this->error_object = $this->raiseError($p_message);
+ }
+
+ /**
+ * @param string $p_message
+ */
+ public function _warning($p_message)
+ {
+ $this->error_object = $this->raiseError($p_message);
+ }
+
+ /**
+ * @param string $p_filename
+ * @return bool
+ */
+ public function _isArchive($p_filename = null)
+ {
+ if ($p_filename == null) {
+ $p_filename = $this->_tarname;
+ }
+ clearstatcache();
+ return @is_file($p_filename) && !@is_link($p_filename);
+ }
+
+ /**
+ * @return bool
+ */
+ public function _openWrite()
+ {
+ if ($this->_compress_type == 'gz' && function_exists('gzopen')) {
+ $this->_file = @gzopen($this->_tarname, "wb9");
+ } else {
+ if ($this->_compress_type == 'bz2' && function_exists('bzopen')) {
+ $this->_file = @bzopen($this->_tarname, "w");
+ } else {
+ if ($this->_compress_type == 'lzma2' && function_exists('xzopen')) {
+ $this->_file = @xzopen($this->_tarname, 'w');
+ } else {
+ if ($this->_compress_type == 'none') {
+ $this->_file = @fopen($this->_tarname, "wb");
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ return false;
+ }
+ }
+ }
+ }
+
+ if ($this->_file == 0) {
+ $this->_error(
+ 'Unable to open in write mode \''
+ . $this->_tarname . '\''
+ );
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * @return bool
+ */
+ public function _openRead()
+ {
+ if (strtolower(substr($this->_tarname, 0, 7)) == 'http://') {
+
+ // ----- Look if a local copy need to be done
+ if ($this->_temp_tarname == '') {
+ $this->_temp_tarname = uniqid('tar') . '.tmp';
+ if (!$v_file_from = @fopen($this->_tarname, 'rb')) {
+ $this->_error(
+ 'Unable to open in read mode \''
+ . $this->_tarname . '\''
+ );
+ $this->_temp_tarname = '';
+ return false;
+ }
+ if (!$v_file_to = @fopen($this->_temp_tarname, 'wb')) {
+ $this->_error(
+ 'Unable to open in write mode \''
+ . $this->_temp_tarname . '\''
+ );
+ $this->_temp_tarname = '';
+ return false;
+ }
+ while ($v_data = @fread($v_file_from, 1024)) {
+ @fwrite($v_file_to, $v_data);
+ }
+ @fclose($v_file_from);
+ @fclose($v_file_to);
+ }
+
+ // ----- File to open if the local copy
+ $v_filename = $this->_temp_tarname;
+ } else {
+ // ----- File to open if the normal Tar file
+
+ $v_filename = $this->_tarname;
+ }
+
+ if ($this->_compress_type == 'gz' && function_exists('gzopen')) {
+ $this->_file = @gzopen($v_filename, "rb");
+ } else {
+ if ($this->_compress_type == 'bz2' && function_exists('bzopen')) {
+ $this->_file = @bzopen($v_filename, "r");
+ } else {
+ if ($this->_compress_type == 'lzma2' && function_exists('xzopen')) {
+ $this->_file = @xzopen($v_filename, "r");
+ } else {
+ if ($this->_compress_type == 'none') {
+ $this->_file = @fopen($v_filename, "rb");
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ return false;
+ }
+ }
+ }
+ }
+
+ if ($this->_file == 0) {
+ $this->_error('Unable to open in read mode \'' . $v_filename . '\'');
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * @return bool
+ */
+ public function _openReadWrite()
+ {
+ if ($this->_compress_type == 'gz') {
+ $this->_file = @gzopen($this->_tarname, "r+b");
+ } else {
+ if ($this->_compress_type == 'bz2') {
+ $this->_error(
+ 'Unable to open bz2 in read/write mode \''
+ . $this->_tarname . '\' (limitation of bz2 extension)'
+ );
+ return false;
+ } else {
+ if ($this->_compress_type == 'lzma2') {
+ $this->_error(
+ 'Unable to open lzma2 in read/write mode \''
+ . $this->_tarname . '\' (limitation of lzma2 extension)'
+ );
+ return false;
+ } else {
+ if ($this->_compress_type == 'none') {
+ $this->_file = @fopen($this->_tarname, "r+b");
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ return false;
+ }
+ }
+ }
+ }
+
+ if ($this->_file == 0) {
+ $this->_error(
+ 'Unable to open in read/write mode \''
+ . $this->_tarname . '\''
+ );
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * @return bool
+ */
+ public function _close()
+ {
+ //if (isset($this->_file)) {
+ if (is_resource($this->_file)) {
+ if ($this->_compress_type == 'gz') {
+ @gzclose($this->_file);
+ } else {
+ if ($this->_compress_type == 'bz2') {
+ @bzclose($this->_file);
+ } else {
+ if ($this->_compress_type == 'lzma2') {
+ @xzclose($this->_file);
+ } else {
+ if ($this->_compress_type == 'none') {
+ @fclose($this->_file);
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ }
+ }
+ }
+ }
+
+ $this->_file = 0;
+ }
+
+ // ----- Look if a local copy need to be erase
+ // Note that it might be interesting to keep the url for a time : ToDo
+ if ($this->_temp_tarname != '') {
+ @unlink($this->_temp_tarname);
+ $this->_temp_tarname = '';
+ }
+
+ return true;
+ }
+
+ /**
+ * @return bool
+ */
+ public function _cleanFile()
+ {
+ $this->_close();
+
+ // ----- Look for a local copy
+ if ($this->_temp_tarname != '') {
+ // ----- Remove the local copy but not the remote tarname
+ @unlink($this->_temp_tarname);
+ $this->_temp_tarname = '';
+ } else {
+ // ----- Remove the local tarname file
+ @unlink($this->_tarname);
+ }
+ $this->_tarname = '';
+
+ return true;
+ }
+
+ /**
+ * @param mixed $p_binary_data
+ * @param integer $p_len
+ * @return bool
+ */
+ public function _writeBlock($p_binary_data, $p_len = null)
+ {
+ if (is_resource($this->_file)) {
+ if ($p_len === null) {
+ if ($this->_compress_type == 'gz') {
+ @gzputs($this->_file, $p_binary_data);
+ } else {
+ if ($this->_compress_type == 'bz2') {
+ @bzwrite($this->_file, $p_binary_data);
+ } else {
+ if ($this->_compress_type == 'lzma2') {
+ @xzwrite($this->_file, $p_binary_data);
+ } else {
+ if ($this->_compress_type == 'none') {
+ @fputs($this->_file, $p_binary_data);
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ }
+ }
+ }
+ }
+ } else {
+ if ($this->_compress_type == 'gz') {
+ @gzputs($this->_file, $p_binary_data, $p_len);
+ } else {
+ if ($this->_compress_type == 'bz2') {
+ @bzwrite($this->_file, $p_binary_data, $p_len);
+ } else {
+ if ($this->_compress_type == 'lzma2') {
+ @xzwrite($this->_file, $p_binary_data, $p_len);
+ } else {
+ if ($this->_compress_type == 'none') {
+ @fputs($this->_file, $p_binary_data, $p_len);
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ }
+ }
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * @return null|string
+ */
+ public function _readBlock()
+ {
+ $v_block = null;
+ if (is_resource($this->_file)) {
+ if ($this->_compress_type == 'gz') {
+ $v_block = @gzread($this->_file, 512);
+ } else {
+ if ($this->_compress_type == 'bz2') {
+ $v_block = @bzread($this->_file, 512);
+ } else {
+ if ($this->_compress_type == 'lzma2') {
+ $v_block = @xzread($this->_file, 512);
+ } else {
+ if ($this->_compress_type == 'none') {
+ $v_block = @fread($this->_file, 512);
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ }
+ }
+ }
+ }
+ }
+ return $v_block;
+ }
+
+ /**
+ * @param null $p_len
+ * @return bool
+ */
+ public function _jumpBlock($p_len = null)
+ {
+ if (is_resource($this->_file)) {
+ if ($p_len === null) {
+ $p_len = 1;
+ }
+
+ if ($this->_compress_type == 'gz') {
+ @gzseek($this->_file, gztell($this->_file) + ($p_len * 512));
+ } else {
+ if ($this->_compress_type == 'bz2') {
+ // ----- Replace missing bztell() and bzseek()
+ for ($i = 0; $i < $p_len; $i++) {
+ $this->_readBlock();
+ }
+ } else {
+ if ($this->_compress_type == 'lzma2') {
+ // ----- Replace missing xztell() and xzseek()
+ for ($i = 0; $i < $p_len; $i++) {
+ $this->_readBlock();
+ }
+ } else {
+ if ($this->_compress_type == 'none') {
+ @fseek($this->_file, $p_len * 512, SEEK_CUR);
+ } else {
+ $this->_error(
+ 'Unknown or missing compression type ('
+ . $this->_compress_type . ')'
+ );
+ }
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * @return bool
+ */
+ public function _writeFooter()
+ {
+ if (is_resource($this->_file)) {
+ // ----- Write the last 0 filled block for end of archive
+ $v_binary_data = pack('a1024', '');
+ $this->_writeBlock($v_binary_data);
+ }
+ return true;
+ }
+
+ /**
+ * @param array $p_list
+ * @param string $p_add_dir
+ * @param string $p_remove_dir
+ * @return bool
+ */
+ public function _addList($p_list, $p_add_dir, $p_remove_dir)
+ {
+ $v_result = true;
+ $v_header = array();
+
+ // ----- Remove potential windows directory separator
+ $p_add_dir = $this->_translateWinPath($p_add_dir);
+ $p_remove_dir = $this->_translateWinPath($p_remove_dir, false);
+
+ if (!$this->_file) {
+ $this->_error('Invalid file descriptor');
+ return false;
+ }
+
+ if (sizeof($p_list) == 0) {
+ return true;
+ }
+
+ foreach ($p_list as $v_filename) {
+ if (!$v_result) {
+ break;
+ }
+
+ // ----- Skip the current tar name
+ if ($v_filename == $this->_tarname) {
+ continue;
+ }
+
+ if ($v_filename == '') {
+ continue;
+ }
+
+ // ----- ignore files and directories matching the ignore regular expression
+ if ($this->_ignore_regexp && preg_match($this->_ignore_regexp, '/' . $v_filename)) {
+ $this->_warning("File '$v_filename' ignored");
+ continue;
+ }
+
+ if (!file_exists($v_filename) && !is_link($v_filename)) {
+ $this->_warning("File '$v_filename' does not exist");
+ continue;
+ }
+
+ // ----- Add the file or directory header
+ if (!$this->_addFile($v_filename, $v_header, $p_add_dir, $p_remove_dir)) {
+ return false;
+ }
+
+ if (@is_dir($v_filename) && !@is_link($v_filename)) {
+ if (!($p_hdir = opendir($v_filename))) {
+ $this->_warning("Directory '$v_filename' can not be read");
+ continue;
+ }
+ while (false !== ($p_hitem = readdir($p_hdir))) {
+ if (($p_hitem != '.') && ($p_hitem != '..')) {
+ if ($v_filename != ".") {
+ $p_temp_list[0] = $v_filename . '/' . $p_hitem;
+ } else {
+ $p_temp_list[0] = $p_hitem;
+ }
+
+ $v_result = $this->_addList(
+ $p_temp_list,
+ $p_add_dir,
+ $p_remove_dir
+ );
+ }
+ }
+
+ unset($p_temp_list);
+ unset($p_hdir);
+ unset($p_hitem);
+ }
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * @param string $p_filename
+ * @param mixed $p_header
+ * @param string $p_add_dir
+ * @param string $p_remove_dir
+ * @param null $v_stored_filename
+ * @return bool
+ */
+ public function _addFile($p_filename, &$p_header, $p_add_dir, $p_remove_dir, $v_stored_filename = null)
+ {
+ if (!$this->_file) {
+ $this->_error('Invalid file descriptor');
+ return false;
+ }
+
+ if ($p_filename == '') {
+ $this->_error('Invalid file name');
+ return false;
+ }
+
+ if (is_null($v_stored_filename)) {
+ // ----- Calculate the stored filename
+ $p_filename = $this->_translateWinPath($p_filename, false);
+ $v_stored_filename = $p_filename;
+
+ if (strcmp($p_filename, $p_remove_dir) == 0) {
+ return true;
+ }
+
+ if ($p_remove_dir != '') {
+ if (substr($p_remove_dir, -1) != '/') {
+ $p_remove_dir .= '/';
+ }
+
+ if (substr($p_filename, 0, strlen($p_remove_dir)) == $p_remove_dir) {
+ $v_stored_filename = substr($p_filename, strlen($p_remove_dir));
+ }
+ }
+
+ $v_stored_filename = $this->_translateWinPath($v_stored_filename);
+ if ($p_add_dir != '') {
+ if (substr($p_add_dir, -1) == '/') {
+ $v_stored_filename = $p_add_dir . $v_stored_filename;
+ } else {
+ $v_stored_filename = $p_add_dir . '/' . $v_stored_filename;
+ }
+ }
+
+ $v_stored_filename = $this->_pathReduction($v_stored_filename);
+ }
+
+ if ($this->_isArchive($p_filename)) {
+ if (($v_file = @fopen($p_filename, "rb")) == 0) {
+ $this->_warning(
+ "Unable to open file '" . $p_filename
+ . "' in binary read mode"
+ );
+ return true;
+ }
+
+ if (!$this->_writeHeader($p_filename, $v_stored_filename)) {
+ return false;
+ }
+
+ while (($v_buffer = fread($v_file, 512)) != '') {
+ $v_binary_data = pack("a512", "$v_buffer");
+ $this->_writeBlock($v_binary_data);
+ }
+
+ fclose($v_file);
+ } else {
+ // ----- Only header for dir
+ if (!$this->_writeHeader($p_filename, $v_stored_filename)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * @param string $p_filename
+ * @param string $p_string
+ * @param bool $p_datetime
+ * @param array $p_params
+ * @return bool
+ */
+ public function _addString($p_filename, $p_string, $p_datetime = false, $p_params = array())
+ {
+ $p_stamp = @$p_params["stamp"] ? $p_params["stamp"] : ($p_datetime ? $p_datetime : time());
+ $p_mode = @$p_params["mode"] ? $p_params["mode"] : 0600;
+ $p_type = @$p_params["type"] ? $p_params["type"] : "";
+ $p_uid = @$p_params["uid"] ? $p_params["uid"] : 0;
+ $p_gid = @$p_params["gid"] ? $p_params["gid"] : 0;
+ if (!$this->_file) {
+ $this->_error('Invalid file descriptor');
+ return false;
+ }
+
+ if ($p_filename == '') {
+ $this->_error('Invalid file name');
+ return false;
+ }
+
+ // ----- Calculate the stored filename
+ $p_filename = $this->_translateWinPath($p_filename, false);
+
+ // ----- If datetime is not specified, set current time
+ if ($p_datetime === false) {
+ $p_datetime = time();
+ }
+
+ if (!$this->_writeHeaderBlock(
+ $p_filename,
+ strlen($p_string),
+ $p_stamp,
+ $p_mode,
+ $p_type,
+ $p_uid,
+ $p_gid
+ )
+ ) {
+ return false;
+ }
+
+ $i = 0;
+ while (($v_buffer = substr($p_string, (($i++) * 512), 512)) != '') {
+ $v_binary_data = pack("a512", $v_buffer);
+ $this->_writeBlock($v_binary_data);
+ }
+
+ return true;
+ }
+
+ /**
+ * @param string $p_filename
+ * @param string $p_stored_filename
+ * @return bool
+ */
+ public function _writeHeader($p_filename, $p_stored_filename)
+ {
+ if ($p_stored_filename == '') {
+ $p_stored_filename = $p_filename;
+ }
+ $v_reduce_filename = $this->_pathReduction($p_stored_filename);
+
+ if (strlen($v_reduce_filename) > 99) {
+ if (!$this->_writeLongHeader($v_reduce_filename)) {
+ return false;
+ }
+ }
+
+ $v_info = lstat($p_filename);
+ $v_uid = sprintf("%07s", DecOct($v_info[4]));
+ $v_gid = sprintf("%07s", DecOct($v_info[5]));
+ $v_perms = sprintf("%07s", DecOct($v_info['mode'] & 000777));
+
+ $v_mtime = sprintf("%011s", DecOct($v_info['mtime']));
+
+ $v_linkname = '';
+
+ if (@is_link($p_filename)) {
+ $v_typeflag = '2';
+ $v_linkname = readlink($p_filename);
+ $v_size = sprintf("%011s", DecOct(0));
+ } elseif (@is_dir($p_filename)) {
+ $v_typeflag = "5";
+ $v_size = sprintf("%011s", DecOct(0));
+ } else {
+ $v_typeflag = '0';
+ clearstatcache();
+ $v_size = sprintf("%011s", DecOct($v_info['size']));
+ }
+
+ $v_magic = 'ustar ';
+
+ $v_version = ' ';
+
+ if (function_exists('posix_getpwuid')) {
+ $userinfo = posix_getpwuid($v_info[4]);
+ $groupinfo = posix_getgrgid($v_info[5]);
+
+ $v_uname = $userinfo['name'];
+ $v_gname = $groupinfo['name'];
+ } else {
+ $v_uname = '';
+ $v_gname = '';
+ }
+
+ $v_devmajor = '';
+
+ $v_devminor = '';
+
+ $v_prefix = '';
+
+ $v_binary_data_first = pack(
+ "a100a8a8a8a12a12",
+ $v_reduce_filename,
+ $v_perms,
+ $v_uid,
+ $v_gid,
+ $v_size,
+ $v_mtime
+ );
+ $v_binary_data_last = pack(
+ "a1a100a6a2a32a32a8a8a155a12",
+ $v_typeflag,
+ $v_linkname,
+ $v_magic,
+ $v_version,
+ $v_uname,
+ $v_gname,
+ $v_devmajor,
+ $v_devminor,
+ $v_prefix,
+ ''
+ );
+
+ // ----- Calculate the checksum
+ $v_checksum = 0;
+ // ..... First part of the header
+ for ($i = 0; $i < 148; $i++) {
+ $v_checksum += ord(substr($v_binary_data_first, $i, 1));
+ }
+ // ..... Ignore the checksum value and replace it by ' ' (space)
+ for ($i = 148; $i < 156; $i++) {
+ $v_checksum += ord(' ');
+ }
+ // ..... Last part of the header
+ for ($i = 156, $j = 0; $i < 512; $i++, $j++) {
+ $v_checksum += ord(substr($v_binary_data_last, $j, 1));
+ }
+
+ // ----- Write the first 148 bytes of the header in the archive
+ $this->_writeBlock($v_binary_data_first, 148);
+
+ // ----- Write the calculated checksum
+ $v_checksum = sprintf("%06s ", DecOct($v_checksum));
+ $v_binary_data = pack("a8", $v_checksum);
+ $this->_writeBlock($v_binary_data, 8);
+
+ // ----- Write the last 356 bytes of the header in the archive
+ $this->_writeBlock($v_binary_data_last, 356);
+
+ return true;
+ }
+
+ /**
+ * @param string $p_filename
+ * @param int $p_size
+ * @param int $p_mtime
+ * @param int $p_perms
+ * @param string $p_type
+ * @param int $p_uid
+ * @param int $p_gid
+ * @return bool
+ */
+ public function _writeHeaderBlock(
+ $p_filename,
+ $p_size,
+ $p_mtime = 0,
+ $p_perms = 0,
+ $p_type = '',
+ $p_uid = 0,
+ $p_gid = 0
+ ) {
+ $p_filename = $this->_pathReduction($p_filename);
+
+ if (strlen($p_filename) > 99) {
+ if (!$this->_writeLongHeader($p_filename)) {
+ return false;
+ }
+ }
+
+ if ($p_type == "5") {
+ $v_size = sprintf("%011s", DecOct(0));
+ } else {
+ $v_size = sprintf("%011s", DecOct($p_size));
+ }
+
+ $v_uid = sprintf("%07s", DecOct($p_uid));
+ $v_gid = sprintf("%07s", DecOct($p_gid));
+ $v_perms = sprintf("%07s", DecOct($p_perms & 000777));
+
+ $v_mtime = sprintf("%11s", DecOct($p_mtime));
+
+ $v_linkname = '';
+
+ $v_magic = 'ustar ';
+
+ $v_version = ' ';
+
+ if (function_exists('posix_getpwuid')) {
+ $userinfo = posix_getpwuid($p_uid);
+ $groupinfo = posix_getgrgid($p_gid);
+
+ $v_uname = $userinfo['name'];
+ $v_gname = $groupinfo['name'];
+ } else {
+ $v_uname = '';
+ $v_gname = '';
+ }
+
+ $v_devmajor = '';
+
+ $v_devminor = '';
+
+ $v_prefix = '';
+
+ $v_binary_data_first = pack(
+ "a100a8a8a8a12A12",
+ $p_filename,
+ $v_perms,
+ $v_uid,
+ $v_gid,
+ $v_size,
+ $v_mtime
+ );
+ $v_binary_data_last = pack(
+ "a1a100a6a2a32a32a8a8a155a12",
+ $p_type,
+ $v_linkname,
+ $v_magic,
+ $v_version,
+ $v_uname,
+ $v_gname,
+ $v_devmajor,
+ $v_devminor,
+ $v_prefix,
+ ''
+ );
+
+ // ----- Calculate the checksum
+ $v_checksum = 0;
+ // ..... First part of the header
+ for ($i = 0; $i < 148; $i++) {
+ $v_checksum += ord(substr($v_binary_data_first, $i, 1));
+ }
+ // ..... Ignore the checksum value and replace it by ' ' (space)
+ for ($i = 148; $i < 156; $i++) {
+ $v_checksum += ord(' ');
+ }
+ // ..... Last part of the header
+ for ($i = 156, $j = 0; $i < 512; $i++, $j++) {
+ $v_checksum += ord(substr($v_binary_data_last, $j, 1));
+ }
+
+ // ----- Write the first 148 bytes of the header in the archive
+ $this->_writeBlock($v_binary_data_first, 148);
+
+ // ----- Write the calculated checksum
+ $v_checksum = sprintf("%06s ", DecOct($v_checksum));
+ $v_binary_data = pack("a8", $v_checksum);
+ $this->_writeBlock($v_binary_data, 8);
+
+ // ----- Write the last 356 bytes of the header in the archive
+ $this->_writeBlock($v_binary_data_last, 356);
+
+ return true;
+ }
+
+ /**
+ * @param string $p_filename
+ * @return bool
+ */
+ public function _writeLongHeader($p_filename)
+ {
+ $v_size = sprintf("%11s ", DecOct(strlen($p_filename)));
+
+ $v_typeflag = 'L';
+
+ $v_linkname = '';
+
+ $v_magic = '';
+
+ $v_version = '';
+
+ $v_uname = '';
+
+ $v_gname = '';
+
+ $v_devmajor = '';
+
+ $v_devminor = '';
+
+ $v_prefix = '';
+
+ $v_binary_data_first = pack(
+ "a100a8a8a8a12a12",
+ '././@LongLink',
+ 0,
+ 0,
+ 0,
+ $v_size,
+ 0
+ );
+ $v_binary_data_last = pack(
+ "a1a100a6a2a32a32a8a8a155a12",
+ $v_typeflag,
+ $v_linkname,
+ $v_magic,
+ $v_version,
+ $v_uname,
+ $v_gname,
+ $v_devmajor,
+ $v_devminor,
+ $v_prefix,
+ ''
+ );
+
+ // ----- Calculate the checksum
+ $v_checksum = 0;
+ // ..... First part of the header
+ for ($i = 0; $i < 148; $i++) {
+ $v_checksum += ord(substr($v_binary_data_first, $i, 1));
+ }
+ // ..... Ignore the checksum value and replace it by ' ' (space)
+ for ($i = 148; $i < 156; $i++) {
+ $v_checksum += ord(' ');
+ }
+ // ..... Last part of the header
+ for ($i = 156, $j = 0; $i < 512; $i++, $j++) {
+ $v_checksum += ord(substr($v_binary_data_last, $j, 1));
+ }
+
+ // ----- Write the first 148 bytes of the header in the archive
+ $this->_writeBlock($v_binary_data_first, 148);
+
+ // ----- Write the calculated checksum
+ $v_checksum = sprintf("%06s ", DecOct($v_checksum));
+ $v_binary_data = pack("a8", $v_checksum);
+ $this->_writeBlock($v_binary_data, 8);
+
+ // ----- Write the last 356 bytes of the header in the archive
+ $this->_writeBlock($v_binary_data_last, 356);
+
+ // ----- Write the filename as content of the block
+ $i = 0;
+ while (($v_buffer = substr($p_filename, (($i++) * 512), 512)) != '') {
+ $v_binary_data = pack("a512", "$v_buffer");
+ $this->_writeBlock($v_binary_data);
+ }
+
+ return true;
+ }
+
+ /**
+ * @param mixed $v_binary_data
+ * @param mixed $v_header
+ * @return bool
+ */
+ public function _readHeader($v_binary_data, &$v_header)
+ {
+ if (strlen($v_binary_data) == 0) {
+ $v_header['filename'] = '';
+ return true;
+ }
+
+ if (strlen($v_binary_data) != 512) {
+ $v_header['filename'] = '';
+ $this->_error('Invalid block size : ' . strlen($v_binary_data));
+ return false;
+ }
+
+ if (!is_array($v_header)) {
+ $v_header = array();
+ }
+ // ----- Calculate the checksum
+ $v_checksum = 0;
+ // ..... First part of the header
+ for ($i = 0; $i < 148; $i++) {
+ $v_checksum += ord(substr($v_binary_data, $i, 1));
+ }
+ // ..... Ignore the checksum value and replace it by ' ' (space)
+ for ($i = 148; $i < 156; $i++) {
+ $v_checksum += ord(' ');
+ }
+ // ..... Last part of the header
+ for ($i = 156; $i < 512; $i++) {
+ $v_checksum += ord(substr($v_binary_data, $i, 1));
+ }
+
+ if (version_compare(PHP_VERSION, "5.5.0-dev") < 0) {
+ $fmt = "a100filename/a8mode/a8uid/a8gid/a12size/a12mtime/" .
+ "a8checksum/a1typeflag/a100link/a6magic/a2version/" .
+ "a32uname/a32gname/a8devmajor/a8devminor/a131prefix";
+ } else {
+ $fmt = "Z100filename/Z8mode/Z8uid/Z8gid/Z12size/Z12mtime/" .
+ "Z8checksum/Z1typeflag/Z100link/Z6magic/Z2version/" .
+ "Z32uname/Z32gname/Z8devmajor/Z8devminor/Z131prefix";
+ }
+ $v_data = unpack($fmt, $v_binary_data);
+
+ if (strlen($v_data["prefix"]) > 0) {
+ $v_data["filename"] = "$v_data[prefix]/$v_data[filename]";
+ }
+
+ // ----- Extract the checksum
+ $v_header['checksum'] = OctDec(trim($v_data['checksum']));
+ if ($v_header['checksum'] != $v_checksum) {
+ $v_header['filename'] = '';
+
+ // ----- Look for last block (empty block)
+ if (($v_checksum == 256) && ($v_header['checksum'] == 0)) {
+ return true;
+ }
+
+ $this->_error(
+ 'Invalid checksum for file "' . $v_data['filename']
+ . '" : ' . $v_checksum . ' calculated, '
+ . $v_header['checksum'] . ' expected'
+ );
+ return false;
+ }
+
+ // ----- Extract the properties
+ $v_header['filename'] = rtrim($v_data['filename'], "\0");
+ if ($this->_maliciousFilename($v_header['filename'])) {
+ $this->_error(
+ 'Malicious .tar detected, file "' . $v_header['filename'] .
+ '" will not install in desired directory tree'
+ );
+ return false;
+ }
+ $v_header['mode'] = OctDec(trim($v_data['mode']));
+ $v_header['uid'] = OctDec(trim($v_data['uid']));
+ $v_header['gid'] = OctDec(trim($v_data['gid']));
+ $v_header['size'] = OctDec(trim($v_data['size']));
+ $v_header['mtime'] = OctDec(trim($v_data['mtime']));
+ if (($v_header['typeflag'] = $v_data['typeflag']) == "5") {
+ $v_header['size'] = 0;
+ }
+ $v_header['link'] = trim($v_data['link']);
+ /* ----- All these fields are removed form the header because
+ they do not carry interesting info
+ $v_header[magic] = trim($v_data[magic]);
+ $v_header[version] = trim($v_data[version]);
+ $v_header[uname] = trim($v_data[uname]);
+ $v_header[gname] = trim($v_data[gname]);
+ $v_header[devmajor] = trim($v_data[devmajor]);
+ $v_header[devminor] = trim($v_data[devminor]);
+ */
+
+ return true;
+ }
+
+ /**
+ * Detect and report a malicious file name
+ *
+ * @param string $file
+ *
+ * @return bool
+ */
+ private function _maliciousFilename($file)
+ {
+ if (strpos($file, '/../') !== false) {
+ return true;
+ }
+ if (strpos($file, '../') === 0) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * @param $v_header
+ * @return bool
+ */
+ public function _readLongHeader(&$v_header)
+ {
+ $v_filename = '';
+ $v_filesize = $v_header['size'];
+ $n = floor($v_header['size'] / 512);
+ for ($i = 0; $i < $n; $i++) {
+ $v_content = $this->_readBlock();
+ $v_filename .= $v_content;
+ }
+ if (($v_header['size'] % 512) != 0) {
+ $v_content = $this->_readBlock();
+ $v_filename .= $v_content;
+ }
+
+ // ----- Read the next header
+ $v_binary_data = $this->_readBlock();
+
+ if (!$this->_readHeader($v_binary_data, $v_header)) {
+ return false;
+ }
+
+ $v_filename = rtrim(substr($v_filename, 0, $v_filesize), "\0");
+ $v_header['filename'] = $v_filename;
+ if ($this->_maliciousFilename($v_filename)) {
+ $this->_error(
+ 'Malicious .tar detected, file "' . $v_filename .
+ '" will not install in desired directory tree'
+ );
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * This method extract from the archive one file identified by $p_filename.
+ * The return value is a string with the file content, or null on error.
+ *
+ * @param string $p_filename The path of the file to extract in a string.
+ *
+ * @return a string with the file content or null.
+ */
+ private function _extractInString($p_filename)
+ {
+ $v_result_str = "";
+
+ while (strlen($v_binary_data = $this->_readBlock()) != 0) {
+ if (!$this->_readHeader($v_binary_data, $v_header)) {
+ return null;
+ }
+
+ if ($v_header['filename'] == '') {
+ continue;
+ }
+
+ // ----- Look for long filename
+ if ($v_header['typeflag'] == 'L') {
+ if (!$this->_readLongHeader($v_header)) {
+ return null;
+ }
+ }
+
+ if ($v_header['filename'] == $p_filename) {
+ if ($v_header['typeflag'] == "5") {
+ $this->_error(
+ 'Unable to extract in string a directory '
+ . 'entry {' . $v_header['filename'] . '}'
+ );
+ return null;
+ } else {
+ $n = floor($v_header['size'] / 512);
+ for ($i = 0; $i < $n; $i++) {
+ $v_result_str .= $this->_readBlock();
+ }
+ if (($v_header['size'] % 512) != 0) {
+ $v_content = $this->_readBlock();
+ $v_result_str .= substr(
+ $v_content,
+ 0,
+ ($v_header['size'] % 512)
+ );
+ }
+ return $v_result_str;
+ }
+ } else {
+ $this->_jumpBlock(ceil(($v_header['size'] / 512)));
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * @param string $p_path
+ * @param string $p_list_detail
+ * @param string $p_mode
+ * @param string $p_file_list
+ * @param string $p_remove_path
+ * @param bool $p_preserve
+ * @return bool
+ */
+ public function _extractList(
+ $p_path,
+ &$p_list_detail,
+ $p_mode,
+ $p_file_list,
+ $p_remove_path,
+ $p_preserve = false
+ ) {
+ $v_result = true;
+ $v_nb = 0;
+ $v_extract_all = true;
+ $v_listing = false;
+
+ $p_path = $this->_translateWinPath($p_path, false);
+ if ($p_path == '' || (substr($p_path, 0, 1) != '/'
+ && substr($p_path, 0, 3) != "../" && !strpos($p_path, ':'))
+ ) {
+ $p_path = "./" . $p_path;
+ }
+ $p_remove_path = $this->_translateWinPath($p_remove_path);
+
+ // ----- Look for path to remove format (should end by /)
+ if (($p_remove_path != '') && (substr($p_remove_path, -1) != '/')) {
+ $p_remove_path .= '/';
+ }
+ $p_remove_path_size = strlen($p_remove_path);
+
+ switch ($p_mode) {
+ case "complete" :
+ $v_extract_all = true;
+ $v_listing = false;
+ break;
+ case "partial" :
+ $v_extract_all = false;
+ $v_listing = false;
+ break;
+ case "list" :
+ $v_extract_all = false;
+ $v_listing = true;
+ break;
+ default :
+ $this->_error('Invalid extract mode (' . $p_mode . ')');
+ return false;
+ }
+
+ clearstatcache();
+
+ while (strlen($v_binary_data = $this->_readBlock()) != 0) {
+ $v_extract_file = false;
+ $v_extraction_stopped = 0;
+
+ if (!$this->_readHeader($v_binary_data, $v_header)) {
+ return false;
+ }
+
+ if ($v_header['filename'] == '') {
+ continue;
+ }
+
+ // ----- Look for long filename
+ if ($v_header['typeflag'] == 'L') {
+ if (!$this->_readLongHeader($v_header)) {
+ return false;
+ }
+ }
+
+ // ignore extended / pax headers
+ if ($v_header['typeflag'] == 'x' || $v_header['typeflag'] == 'g') {
+ $this->_jumpBlock(ceil(($v_header['size'] / 512)));
+ continue;
+ }
+
+ if ((!$v_extract_all) && (is_array($p_file_list))) {
+ // ----- By default no unzip if the file is not found
+ $v_extract_file = false;
+
+ for ($i = 0; $i < sizeof($p_file_list); $i++) {
+ // ----- Look if it is a directory
+ if (substr($p_file_list[$i], -1) == '/') {
+ // ----- Look if the directory is in the filename path
+ if ((strlen($v_header['filename']) > strlen($p_file_list[$i]))
+ && (substr($v_header['filename'], 0, strlen($p_file_list[$i]))
+ == $p_file_list[$i])
+ ) {
+ $v_extract_file = true;
+ break;
+ }
+ } // ----- It is a file, so compare the file names
+ elseif ($p_file_list[$i] == $v_header['filename']) {
+ $v_extract_file = true;
+ break;
+ }
+ }
+ } else {
+ $v_extract_file = true;
+ }
+
+ // ----- Look if this file need to be extracted
+ if (($v_extract_file) && (!$v_listing)) {
+ if (($p_remove_path != '')
+ && (substr($v_header['filename'] . '/', 0, $p_remove_path_size)
+ == $p_remove_path)
+ ) {
+ $v_header['filename'] = substr(
+ $v_header['filename'],
+ $p_remove_path_size
+ );
+ if ($v_header['filename'] == '') {
+ continue;
+ }
+ }
+ if (($p_path != './') && ($p_path != '/')) {
+ while (substr($p_path, -1) == '/') {
+ $p_path = substr($p_path, 0, strlen($p_path) - 1);
+ }
+
+ if (substr($v_header['filename'], 0, 1) == '/') {
+ $v_header['filename'] = $p_path . $v_header['filename'];
+ } else {
+ $v_header['filename'] = $p_path . '/' . $v_header['filename'];
+ }
+ }
+ if (file_exists($v_header['filename'])) {
+ if ((@is_dir($v_header['filename']))
+ && ($v_header['typeflag'] == '')
+ ) {
+ $this->_error(
+ 'File ' . $v_header['filename']
+ . ' already exists as a directory'
+ );
+ return false;
+ }
+ if (($this->_isArchive($v_header['filename']))
+ && ($v_header['typeflag'] == "5")
+ ) {
+ $this->_error(
+ 'Directory ' . $v_header['filename']
+ . ' already exists as a file'
+ );
+ return false;
+ }
+ if (!is_writeable($v_header['filename'])) {
+ $this->_error(
+ 'File ' . $v_header['filename']
+ . ' already exists and is write protected'
+ );
+ return false;
+ }
+ if (filemtime($v_header['filename']) > $v_header['mtime']) {
+ // To be completed : An error or silent no replace ?
+ }
+ } // ----- Check the directory availability and create it if necessary
+ elseif (($v_result
+ = $this->_dirCheck(
+ ($v_header['typeflag'] == "5"
+ ? $v_header['filename']
+ : dirname($v_header['filename']))
+ )) != 1
+ ) {
+ $this->_error('Unable to create path for ' . $v_header['filename']);
+ return false;
+ }
+
+ if ($v_extract_file) {
+ if ($v_header['typeflag'] == "5") {
+ if (!@file_exists($v_header['filename'])) {
+ if (!@mkdir($v_header['filename'], 0777)) {
+ $this->_error(
+ 'Unable to create directory {'
+ . $v_header['filename'] . '}'
+ );
+ return false;
+ }
+ }
+ } elseif ($v_header['typeflag'] == "2") {
+ if (@file_exists($v_header['filename'])) {
+ @unlink($v_header['filename']);
+ }
+ if (!@symlink($v_header['link'], $v_header['filename'])) {
+ $this->_error(
+ 'Unable to extract symbolic link {'
+ . $v_header['filename'] . '}'
+ );
+ return false;
+ }
+ } else {
+ if (($v_dest_file = @fopen($v_header['filename'], "wb")) == 0) {
+ $this->_error(
+ 'Error while opening {' . $v_header['filename']
+ . '} in write binary mode'
+ );
+ return false;
+ } else {
+ $n = floor($v_header['size'] / 512);
+ for ($i = 0; $i < $n; $i++) {
+ $v_content = $this->_readBlock();
+ fwrite($v_dest_file, $v_content, 512);
+ }
+ if (($v_header['size'] % 512) != 0) {
+ $v_content = $this->_readBlock();
+ fwrite($v_dest_file, $v_content, ($v_header['size'] % 512));
+ }
+
+ @fclose($v_dest_file);
+
+ if ($p_preserve) {
+ @chown($v_header['filename'], $v_header['uid']);
+ @chgrp($v_header['filename'], $v_header['gid']);
+ }
+
+ // ----- Change the file mode, mtime
+ @touch($v_header['filename'], $v_header['mtime']);
+ if ($v_header['mode'] & 0111) {
+ // make file executable, obey umask
+ $mode = fileperms($v_header['filename']) | (~umask() & 0111);
+ @chmod($v_header['filename'], $mode);
+ }
+ }
+
+ // ----- Check the file size
+ clearstatcache();
+ if (!is_file($v_header['filename'])) {
+ $this->_error(
+ 'Extracted file ' . $v_header['filename']
+ . 'does not exist. Archive may be corrupted.'
+ );
+ return false;
+ }
+
+ $filesize = filesize($v_header['filename']);
+ if ($filesize != $v_header['size']) {
+ $this->_error(
+ 'Extracted file ' . $v_header['filename']
+ . ' does not have the correct file size \''
+ . $filesize
+ . '\' (' . $v_header['size']
+ . ' expected). Archive may be corrupted.'
+ );
+ return false;
+ }
+ }
+ } else {
+ $this->_jumpBlock(ceil(($v_header['size'] / 512)));
+ }
+ } else {
+ $this->_jumpBlock(ceil(($v_header['size'] / 512)));
+ }
+
+ /* TBC : Seems to be unused ...
+ if ($this->_compress)
+ $v_end_of_file = @gzeof($this->_file);
+ else
+ $v_end_of_file = @feof($this->_file);
+ */
+
+ if ($v_listing || $v_extract_file || $v_extraction_stopped) {
+ // ----- Log extracted files
+ if (($v_file_dir = dirname($v_header['filename']))
+ == $v_header['filename']
+ ) {
+ $v_file_dir = '';
+ }
+ if ((substr($v_header['filename'], 0, 1) == '/') && ($v_file_dir == '')) {
+ $v_file_dir = '/';
+ }
+
+ $p_list_detail[$v_nb++] = $v_header;
+ if (is_array($p_file_list) && (count($p_list_detail) == count($p_file_list))) {
+ return true;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * @return bool
+ */
+ public function _openAppend()
+ {
+ if (filesize($this->_tarname) == 0) {
+ return $this->_openWrite();
+ }
+
+ if ($this->_compress) {
+ $this->_close();
+
+ if (!@rename($this->_tarname, $this->_tarname . ".tmp")) {
+ $this->_error(
+ 'Error while renaming \'' . $this->_tarname
+ . '\' to temporary file \'' . $this->_tarname
+ . '.tmp\''
+ );
+ return false;
+ }
+
+ if ($this->_compress_type == 'gz') {
+ $v_temp_tar = @gzopen($this->_tarname . ".tmp", "rb");
+ } elseif ($this->_compress_type == 'bz2') {
+ $v_temp_tar = @bzopen($this->_tarname . ".tmp", "r");
+ } elseif ($this->_compress_type == 'lzma2') {
+ $v_temp_tar = @xzopen($this->_tarname . ".tmp", "r");
+ }
+
+
+ if ($v_temp_tar == 0) {
+ $this->_error(
+ 'Unable to open file \'' . $this->_tarname
+ . '.tmp\' in binary read mode'
+ );
+ @rename($this->_tarname . ".tmp", $this->_tarname);
+ return false;
+ }
+
+ if (!$this->_openWrite()) {
+ @rename($this->_tarname . ".tmp", $this->_tarname);
+ return false;
+ }
+
+ if ($this->_compress_type == 'gz') {
+ $end_blocks = 0;
+
+ while (!@gzeof($v_temp_tar)) {
+ $v_buffer = @gzread($v_temp_tar, 512);
+ if ($v_buffer == ARCHIVE_TAR_END_BLOCK || strlen($v_buffer) == 0) {
+ $end_blocks++;
+ // do not copy end blocks, we will re-make them
+ // after appending
+ continue;
+ } elseif ($end_blocks > 0) {
+ for ($i = 0; $i < $end_blocks; $i++) {
+ $this->_writeBlock(ARCHIVE_TAR_END_BLOCK);
+ }
+ $end_blocks = 0;
+ }
+ $v_binary_data = pack("a512", $v_buffer);
+ $this->_writeBlock($v_binary_data);
+ }
+
+ @gzclose($v_temp_tar);
+ } elseif ($this->_compress_type == 'bz2') {
+ $end_blocks = 0;
+
+ while (strlen($v_buffer = @bzread($v_temp_tar, 512)) > 0) {
+ if ($v_buffer == ARCHIVE_TAR_END_BLOCK || strlen($v_buffer) == 0) {
+ $end_blocks++;
+ // do not copy end blocks, we will re-make them
+ // after appending
+ continue;
+ } elseif ($end_blocks > 0) {
+ for ($i = 0; $i < $end_blocks; $i++) {
+ $this->_writeBlock(ARCHIVE_TAR_END_BLOCK);
+ }
+ $end_blocks = 0;
+ }
+ $v_binary_data = pack("a512", $v_buffer);
+ $this->_writeBlock($v_binary_data);
+ }
+
+ @bzclose($v_temp_tar);
+ } elseif ($this->_compress_type == 'lzma2') {
+ $end_blocks = 0;
+
+ while (strlen($v_buffer = @xzread($v_temp_tar, 512)) > 0) {
+ if ($v_buffer == ARCHIVE_TAR_END_BLOCK || strlen($v_buffer) == 0) {
+ $end_blocks++;
+ // do not copy end blocks, we will re-make them
+ // after appending
+ continue;
+ } elseif ($end_blocks > 0) {
+ for ($i = 0; $i < $end_blocks; $i++) {
+ $this->_writeBlock(ARCHIVE_TAR_END_BLOCK);
+ }
+ $end_blocks = 0;
+ }
+ $v_binary_data = pack("a512", $v_buffer);
+ $this->_writeBlock($v_binary_data);
+ }
+
+ @xzclose($v_temp_tar);
+ }
+
+ if (!@unlink($this->_tarname . ".tmp")) {
+ $this->_error(
+ 'Error while deleting temporary file \''
+ . $this->_tarname . '.tmp\''
+ );
+ }
+ } else {
+ // ----- For not compressed tar, just add files before the last
+ // one or two 512 bytes block
+ if (!$this->_openReadWrite()) {
+ return false;
+ }
+
+ clearstatcache();
+ $v_size = filesize($this->_tarname);
+
+ // We might have zero, one or two end blocks.
+ // The standard is two, but we should try to handle
+ // other cases.
+ fseek($this->_file, $v_size - 1024);
+ if (fread($this->_file, 512) == ARCHIVE_TAR_END_BLOCK) {
+ fseek($this->_file, $v_size - 1024);
+ } elseif (fread($this->_file, 512) == ARCHIVE_TAR_END_BLOCK) {
+ fseek($this->_file, $v_size - 512);
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * @param $p_filelist
+ * @param string $p_add_dir
+ * @param string $p_remove_dir
+ * @return bool
+ */
+ public function _append($p_filelist, $p_add_dir = '', $p_remove_dir = '')
+ {
+ if (!$this->_openAppend()) {
+ return false;
+ }
+
+ if ($this->_addList($p_filelist, $p_add_dir, $p_remove_dir)) {
+ $this->_writeFooter();
+ }
+
+ $this->_close();
+
+ return true;
+ }
+
+ /**
+ * Check if a directory exists and create it (including parent
+ * dirs) if not.
+ *
+ * @param string $p_dir directory to check
+ *
+ * @return bool true if the directory exists or was created
+ */
+ public function _dirCheck($p_dir)
+ {
+ clearstatcache();
+ if ((@is_dir($p_dir)) || ($p_dir == '')) {
+ return true;
+ }
+
+ $p_parent_dir = dirname($p_dir);
+
+ if (($p_parent_dir != $p_dir) &&
+ ($p_parent_dir != '') &&
+ (!$this->_dirCheck($p_parent_dir))
+ ) {
+ return false;
+ }
+
+ if (!@mkdir($p_dir, 0777)) {
+ $this->_error("Unable to create directory '$p_dir'");
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Compress path by changing for example "/dir/foo/../bar" to "/dir/bar",
+ * rand emove double slashes.
+ *
+ * @param string $p_dir path to reduce
+ *
+ * @return string reduced path
+ */
+ private function _pathReduction($p_dir)
+ {
+ $v_result = '';
+
+ // ----- Look for not empty path
+ if ($p_dir != '') {
+ // ----- Explode path by directory names
+ $v_list = explode('/', $p_dir);
+
+ // ----- Study directories from last to first
+ for ($i = sizeof($v_list) - 1; $i >= 0; $i--) {
+ // ----- Look for current path
+ if ($v_list[$i] == ".") {
+ // ----- Ignore this directory
+ // Should be the first $i=0, but no check is done
+ } else {
+ if ($v_list[$i] == "..") {
+ // ----- Ignore it and ignore the $i-1
+ $i--;
+ } else {
+ if (($v_list[$i] == '')
+ && ($i != (sizeof($v_list) - 1))
+ && ($i != 0)
+ ) {
+ // ----- Ignore only the double '//' in path,
+ // but not the first and last /
+ } else {
+ $v_result = $v_list[$i] . ($i != (sizeof($v_list) - 1) ? '/'
+ . $v_result : '');
+ }
+ }
+ }
+ }
+ }
+
+ if (defined('OS_WINDOWS') && OS_WINDOWS) {
+ $v_result = strtr($v_result, '\\', '/');
+ }
+
+ return $v_result;
+ }
+
+ /**
+ * @param $p_path
+ * @param bool $p_remove_disk_letter
+ * @return string
+ */
+ public function _translateWinPath($p_path, $p_remove_disk_letter = true)
+ {
+ if (defined('OS_WINDOWS') && OS_WINDOWS) {
+ // ----- Look for potential disk letter
+ if (($p_remove_disk_letter)
+ && (($v_position = strpos($p_path, ':')) != false)
+ ) {
+ $p_path = substr($p_path, $v_position + 1);
+ }
+ // ----- Change potential windows directory separator
+ if ((strpos($p_path, '\\') > 0) || (substr($p_path, 0, 1) == '\\')) {
+ $p_path = strtr($p_path, '\\', '/');
+ }
+ }
+ return $p_path;
+ }
+}
+ Archive_Tar-1.4.0/docs/Archive_Tar.txt 0000664 0001750 0001750 00000045246 12553124254 017411 0 ustar michiel michiel Documentation for class Archive_Tar
+===================================
+Last update : 2001-08-15
+
+
+
+Overview :
+----------
+
+ The Archive_Tar class helps in creating and managing GNU TAR format
+ files compressed by GNU ZIP or not.
+ The class offers basic functions like creating an archive, adding
+ files in the archive, extracting files from the archive and listing
+ the archive content.
+ It also provide advanced functions that allow the adding and
+ extraction of files with path manipulation.
+
+
+Sample :
+--------
+
+ // ----- Creating the object (uncompressed archive)
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->setErrorHandling(PEAR_ERROR_PRINT);
+
+ // ----- Creating the archive
+ $v_list[0]="file.txt";
+ $v_list[1]="data/";
+ $v_list[2]="file.log";
+ $tar_object->create($v_list);
+
+ // ----- Adding files
+ $v_list[0]="dev/file.txt";
+ $v_list[1]="dev/data/";
+ $v_list[2]="log/file.log";
+ $tar_object->add($v_list);
+
+ // ----- Adding more files
+ $tar_object->add("release/newfile.log release/readme.txt");
+
+ // ----- Listing the content
+ if (($v_list = $tar_object->listContent()) != 0)
+ for ($i=0; $i";
+ echo " .size :'".$v_list[$i][size]."' ";
+ echo " .mtime :'".$v_list[$i][mtime]."' (".date("l dS of F Y h:i:s A", $v_list[$i][mtime]).") ";
+ echo " .mode :'".$v_list[$i][mode]."' ";
+ echo " .uid :'".$v_list[$i][uid]."' ";
+ echo " .gid :'".$v_list[$i][gid]."' ";
+ echo " .typeflag :'".$v_list[$i][typeflag]."' ";
+ }
+
+ // ----- Extracting the archive in directory "install"
+ $tar_object->extract("install");
+
+
+Public arguments :
+------------------
+
+None
+
+
+Public Methods :
+----------------
+
+Method : Archive_Tar($p_tarname, $compress = null)
+Description :
+ Archive_Tar Class constructor. This flavour of the constructor only
+ declare a new Archive_Tar object, identifying it by the name of the
+ tar file.
+ If the compress argument is set the tar will be read or created as a
+ gzip or bz2 compressed TAR file.
+Arguments :
+ $p_tarname : A valid filename for the tar archive file.
+ $p_compress : can be null, 'gz' or 'bz2'. For
+ compatibility reason it can also be true. This
+ parameter indicates if gzip or bz2 compression
+ is required.
+Return value :
+ The Archive_Tar object.
+Sample :
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object_compressed = new Archive_Tar("tarname.tgz", true);
+How it works :
+ Initialize the object.
+
+Method : create($p_filelist)
+Description :
+ This method creates the archive file and add the files / directories
+ that are listed in $p_filelist.
+ If the file already exists and is writable, it is replaced by the
+ new tar. It is a create and not an add. If the file exists and is
+ read-only or is a directory it is not replaced. The method return
+ false and a PEAR error text.
+ The $p_filelist parameter can be an array of string, each string
+ representing a filename or a directory name with their path if
+ needed. It can also be a single string with names separated by a
+ single blank.
+ See also createModify() method for more details.
+Arguments :
+ $p_filelist : An array of filenames and directory names, or a single
+ string with names separated by a single blank space.
+Return value :
+ true on success, false on error.
+Sample 1 :
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->setErrorHandling(PEAR_ERROR_PRINT); // Optional error handling
+ $v_list[0]="file.txt";
+ $v_list[1]="data/"; (Optional '/' at the end)
+ $v_list[2]="file.log";
+ $tar_object->create($v_list);
+Sample 2 :
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->setErrorHandling(PEAR_ERROR_PRINT); // Optional error handling
+ $tar_object->create("file.txt data/ file.log");
+How it works :
+ Just calling the createModify() method with the right parameters.
+
+Method : createModify($p_filelist, $p_add_dir, $p_remove_dir = "")
+Description :
+ This method creates the archive file and add the files / directories
+ that are listed in $p_filelist.
+ If the file already exists and is writable, it is replaced by the
+ new tar. It is a create and not an add. If the file exists and is
+ read-only or is a directory it is not replaced. The method return
+ false and a PEAR error text.
+ The $p_filelist parameter can be an array of string, each string
+ representing a filename or a directory name with their path if
+ needed. It can also be a single string with names separated by a
+ single blank.
+ The path indicated in $p_remove_dir will be removed from the
+ memorized path of each file / directory listed when this path
+ exists. By default nothing is removed (empty path "")
+ The path indicated in $p_add_dir will be added at the beginning of
+ the memorized path of each file / directory listed. However it can
+ be set to empty "". The adding of a path is done after the removing
+ of path.
+ The path add/remove ability enables the user to prepare an archive
+ for extraction in a different path than the origin files are.
+ See also addModify() method for file adding properties.
+Arguments :
+ $p_filelist : An array of filenames and directory names, or a single
+ string with names separated by a single blank space.
+ $p_add_dir : A string which contains a path to be added to the
+ memorized path of each element in the list.
+ $p_remove_dir : A string which contains a path to be removed from
+ the memorized path of each element in the list, when
+ relevant.
+Return value :
+ true on success, false on error.
+Sample 1 :
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->setErrorHandling(PEAR_ERROR_PRINT); // Optional error handling
+ $v_list[0]="file.txt";
+ $v_list[1]="data/"; (Optional '/' at the end)
+ $v_list[2]="file.log";
+ $tar_object->createModify($v_list, "install");
+ // files are stored in the archive as :
+ // install/file.txt
+ // install/data
+ // install/data/file1.txt
+ // install/data/... all the files and sub-dirs of data/
+ // install/file.log
+Sample 2 :
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->setErrorHandling(PEAR_ERROR_PRINT); // Optional error handling
+ $v_list[0]="dev/file.txt";
+ $v_list[1]="dev/data/"; (Optional '/' at the end)
+ $v_list[2]="log/file.log";
+ $tar_object->createModify($v_list, "install", "dev");
+ // files are stored in the archive as :
+ // install/file.txt
+ // install/data
+ // install/data/file1.txt
+ // install/data/... all the files and sub-dirs of data/
+ // install/log/file.log
+How it works :
+ Open the file in write mode (erasing the existing one if one),
+ call the _addList() method for adding the files in an empty archive,
+ add the tar footer (512 bytes block), close the tar file.
+
+
+Method : addModify($p_filelist, $p_add_dir, $p_remove_dir="")
+Description :
+ This method add the files / directories listed in $p_filelist at the
+ end of the existing archive. If the archive does not yet exists it
+ is created.
+ The $p_filelist parameter can be an array of string, each string
+ representing a filename or a directory name with their path if
+ needed. It can also be a single string with names separated by a
+ single blank.
+ The path indicated in $p_remove_dir will be removed from the
+ memorized path of each file / directory listed when this path
+ exists. By default nothing is removed (empty path "")
+ The path indicated in $p_add_dir will be added at the beginning of
+ the memorized path of each file / directory listed. However it can
+ be set to empty "". The adding of a path is done after the removing
+ of path.
+ The path add/remove ability enables the user to prepare an archive
+ for extraction in a different path than the origin files are.
+ If a file/dir is already in the archive it will only be added at the
+ end of the archive. There is no update of the existing archived
+ file/dir. However while extracting the archive, the last file will
+ replace the first one. This results in a none optimization of the
+ archive size.
+ If a file/dir does not exist the file/dir is ignored. However an
+ error text is send to PEAR error.
+ If a file/dir is not readable the file/dir is ignored. However an
+ error text is send to PEAR error.
+ If the resulting filename/dirname (after the add/remove option or
+ not) string is greater than 99 char, the file/dir is
+ ignored. However an error text is send to PEAR error.
+Arguments :
+ $p_filelist : An array of filenames and directory names, or a single
+ string with names separated by a single blank space.
+ $p_add_dir : A string which contains a path to be added to the
+ memorized path of each element in the list.
+ $p_remove_dir : A string which contains a path to be removed from
+ the memorized path of each element in the list, when
+ relevant.
+Return value :
+ true on success, false on error.
+Sample 1 :
+ $tar_object = new Archive_Tar("tarname.tar");
+ [...]
+ $v_list[0]="dev/file.txt";
+ $v_list[1]="dev/data/"; (Optional '/' at the end)
+ $v_list[2]="log/file.log";
+ $tar_object->addModify($v_list, "install");
+ // files are stored in the archive as :
+ // install/file.txt
+ // install/data
+ // install/data/file1.txt
+ // install/data/... all the files and sub-dirs of data/
+ // install/file.log
+Sample 2 :
+ $tar_object = new Archive_Tar("tarname.tar");
+ [...]
+ $v_list[0]="dev/file.txt";
+ $v_list[1]="dev/data/"; (Optional '/' at the end)
+ $v_list[2]="log/file.log";
+ $tar_object->addModify($v_list, "install", "dev");
+ // files are stored in the archive as :
+ // install/file.txt
+ // install/data
+ // install/data/file1.txt
+ // install/data/... all the files and sub-dirs of data/
+ // install/log/file.log
+How it works :
+ If the archive does not exists it create it and add the files.
+ If the archive does exists and is not compressed, it open it, jump
+ before the last empty 512 bytes block (tar footer) and add the files
+ at this point.
+ If the archive does exists and is compressed, a temporary copy file
+ is created. This temporary file is then 'gzip' read block by block
+ until the last empty block. The new files are then added in the
+ compressed file.
+ The adding of files is done by going through the file/dir list,
+ adding files per files, in a recursive way through the
+ directory. Each time a path need to be added/removed it is done
+ before writing the file header in the archive.
+
+Method : add($p_filelist)
+Description :
+ This method add the files / directories listed in $p_filelist at the
+ end of the existing archive. If the archive does not yet exists it
+ is created.
+ The $p_filelist parameter can be an array of string, each string
+ representing a filename or a directory name with their path if
+ needed. It can also be a single string with names separated by a
+ single blank.
+ See addModify() method for details and limitations.
+Arguments :
+ $p_filelist : An array of filenames and directory names, or a single
+ string with names separated by a single blank space.
+Return value :
+ true on success, false on error.
+Sample 1 :
+ $tar_object = new Archive_Tar("tarname.tar");
+ [...]
+ $v_list[0]="dev/file.txt";
+ $v_list[1]="dev/data/"; (Optional '/' at the end)
+ $v_list[2]="log/file.log";
+ $tar_object->add($v_list);
+Sample 2 :
+ $tar_object = new Archive_Tar("tarname.tgz", true);
+ [...]
+ $v_list[0]="dev/file.txt";
+ $v_list[1]="dev/data/"; (Optional '/' at the end)
+ $v_list[2]="log/file.log";
+ $tar_object->add($v_list);
+How it works :
+ Simply call the addModify() method with the right parameters.
+
+Method : addString($p_filename, $p_string, $p_datetime, $p_params)
+Description :
+ This method add a single string as a file at the
+ end of the existing archive. If the archive does not yet exists it
+ is created.
+Arguments :
+ $p_filename : A string which contains the full filename path
+ that will be associated with the string.
+ $p_string : The content of the file added in the archive.
+ $p_datetime : (Optional) Timestamp of the file (default = now)
+ $p_params : (Optional) Various file metadata:
+ stamp - As above, timestamp of the file
+ mode - UNIX-style permissions (default 0600)
+ type - Is this a regular file or link (see TAR
+ format spec for how to create a hard/symlink)
+ uid - UNIX-style user ID (default 0 = root)
+ gid - UNIX-style group ID (default 0 = root)
+Return value :
+ true on success, false on error.
+Sample 1 :
+ $v_archive = & new Archive_Tar($p_filename);
+ $v_archive->setErrorHandling(PEAR_ERROR_PRINT);
+ $v_result = $v_archive->addString('data/test.txt', 'This is the text of the string');
+ $v_result = $v_archive->addString(
+ 'data/test.sh',
+ "#!/bin/sh\necho 'Hello'",
+ time(),
+ array( "mode" => 0755, "uid" => 34 )
+ );
+
+
+Method : extract($p_path = "")
+Description :
+ This method extract all the content of the archive in the directory
+ indicated by $p_path.If $p_path is optional, if not set the archive
+ is extracted in the current directory.
+ While extracting a file, if the directory path does not exists it is
+ created.
+ See extractModify() for details and limitations.
+Arguments :
+ $p_path : Optional path where the files/dir need to by extracted.
+Return value :
+ true on success, false on error.
+Sample :
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->extract();
+How it works :
+ Simply call the extractModify() method with appropriate parameters.
+
+Method : extractModify($p_path, $p_remove_path)
+Description :
+ This method extract all the content of the archive in the directory
+ indicated by $p_path. When relevant the memorized path of the
+ files/dir can be modified by removing the $p_remove_path path at the
+ beginning of the file/dir path.
+ While extracting a file, if the directory path does not exists it is
+ created.
+ While extracting a file, if the file already exists it is replaced
+ without looking for last modification date.
+ While extracting a file, if the file already exists and is write
+ protected, the extraction is aborted.
+ While extracting a file, if a directory with the same name already
+ exists, the extraction is aborted.
+ While extracting a directory, if a file with the same name already
+ exists, the extraction is aborted.
+ While extracting a file/directory if the destination directory exist
+ and is write protected, or does not exist but can not be created,
+ the extraction is aborted.
+ If after extraction an extracted file does not show the correct
+ stored file size, the extraction is aborted.
+ When the extraction is aborted, a PEAR error text is set and false
+ is returned. However the result can be a partial extraction that may
+ need to be manually cleaned.
+Arguments :
+ $p_path : The path of the directory where the files/dir need to by
+ extracted.
+ $p_remove_path : Part of the memorized path that can be removed if
+ present at the beginning of the file/dir path.
+Return value :
+ true on success, false on error.
+Sample :
+ // Imagine tarname.tar with files :
+ // dev/data/file.txt
+ // dev/data/log.txt
+ // readme.txt
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->extractModify("install", "dev");
+ // Files will be extracted there :
+ // install/data/file.txt
+ // install/data/log.txt
+ // install/readme.txt
+How it works :
+ Open the archive and call a more generic function that can extract
+ only a part of the archive or all the archive.
+ See extractList() method for more details.
+
+Method : extractInString($p_filename)
+Description :
+ This method extract from the archive one file identified by $p_filename.
+ The return value is a string with the file content, or NULL on error.
+Arguments :
+ $p_filename : The path of the file to extract in a string.
+Return value :
+ a string with the file content or NULL.
+Sample :
+ // Imagine tarname.tar with files :
+ // dev/data/file.txt
+ // dev/data/log.txt
+ // dev/readme.txt
+ $v_archive = & new Archive_Tar('tarname.tar');
+ $v_archive->setErrorHandling(PEAR_ERROR_PRINT);
+ $v_string = $v_archive->extractInString('dev/readme.txt');
+ echo $v_string;
+
+Method : listContent()
+Description :
+ This method returns an array of arrays that describe each
+ file/directory present in the archive.
+ The array is not sorted, so it show the position of the file in the
+ archive.
+ The file informations are :
+ $file[filename] : Name and path of the file/dir.
+ $file[mode] : File permissions (result of fileperms())
+ $file[uid] : user id
+ $file[gid] : group id
+ $file[size] : filesize
+ $file[mtime] : Last modification time (result of filemtime())
+ $file[typeflag] : "" for file, "5" for directory
+Arguments :
+Return value :
+ An array of arrays or 0 on error.
+Sample :
+ $tar_object = new Archive_Tar("tarname.tar");
+ if (($v_list = $tar_object->listContent()) != 0)
+ for ($i=0; $i";
+ echo " .size :'".$v_list[$i][size]."' ";
+ echo " .mtime :'".$v_list[$i][mtime]."' (".
+ date("l dS of F Y h:i:s A", $v_list[$i][mtime]).") ";
+ echo " .mode :'".$v_list[$i][mode]."' ";
+ echo " .uid :'".$v_list[$i][uid]."' ";
+ echo " .gid :'".$v_list[$i][gid]."' ";
+ echo " .typeflag :'".$v_list[$i][typeflag]."' ";
+ }
+How it works :
+ Call the same function as an extract however with a flag to only go
+ through the archive without extracting the files.
+
+Method : extractList($p_filelist, $p_path = "", $p_remove_path = "")
+Description :
+ This method extract from the archive only the files indicated in the
+ $p_filelist. These files are extracted in the current directory or
+ in the directory indicated by the optional $p_path parameter.
+ If indicated the $p_remove_path can be used in the same way as it is
+ used in extractModify() method.
+Arguments :
+ $p_filelist : An array of filenames and directory names, or a single
+ string with names separated by a single blank space.
+ $p_path : The path of the directory where the files/dir need to by
+ extracted.
+ $p_remove_path : Part of the memorized path that can be removed if
+ present at the beginning of the file/dir path.
+Return value :
+ true on success, false on error.
+Sample :
+ // Imagine tarname.tar with files :
+ // dev/data/file.txt
+ // dev/data/log.txt
+ // readme.txt
+ $tar_object = new Archive_Tar("tarname.tar");
+ $tar_object->extractList("dev/data/file.txt readme.txt", "install",
+ "dev");
+ // Files will be extracted there :
+ // install/data/file.txt
+ // install/readme.txt
+How it works :
+ Go through the archive and extract only the files present in the
+ list.
+
+ package.xml 0000644 0001750 0000144 00000015121 12553254770 012556 0 ustar cweiske users
+
+ Console_Getopt
+ pear.php.net
+ Command-line option parser
+ This is a PHP implementation of "getopt" supporting both
+short and long options.
+
+ Andrei Zmievski
+ andrei
+ andrei@php.net
+ no
+
+
+ Stig Bakken
+ ssb
+ stig@php.net
+ no
+
+
+ Greg Beaver
+ cellog
+ cellog@php.net
+ yes
+
+ 2015-07-20
+
+
+ 1.4.1
+ 1.4.0
+
+
+ stable
+ stable
+
+ BSD-2-Clause
+
+* Fix unit test on PHP 7 [cweiske]
+
+
+
+
+
+
+
+
+
+
+
+ PEAR
+ pear.php.net
+ 1.4.0
+ 1.999.999
+
+
+
+
+ 5.4.0
+
+
+ 1.8.0
+
+
+
+
+
+
+ 2015-07-20
+
+ 1.4.1
+ 1.4.0
+
+
+ stable
+ stable
+
+ BSD-2-Clause
+
+* Fix unit test on PHP 7 [cweiske]
+
+
+
+ 2015-02-22
+
+ 1.4.0
+ 1.4.0
+
+
+ stable
+ stable
+
+ BSD-2-Clause
+
+* Change license to BSD-2-Clause
+* Set minimum PHP version to 5.4.0
+* Mark static methods with "static" keyword
+
+
+
+ 2011-03-07
+
+ 1.3.1
+ 1.3.0
+
+
+ stable
+ stable
+
+ PHP License
+
+* Change the minimum PEAR installer dep to be lower
+
+
+
+ 2010-12-11
+
+
+ 1.3.0
+ 1.3.0
+
+
+ stable
+ stable
+
+ PHP License
+
+* Implement Request #13140: [PATCH] to skip unknown parameters. [patch by rquadling, improved on by dufuz]
+
+
+
+ 2007-06-12
+
+ 1.2.3
+ 1.2.1
+
+
+ stable
+ stable
+
+ PHP License
+
+* fix Bug #11068: No way to read plain "-" option [cardoe]
+
+
+
+
+ 1.2.2
+ 1.2.1
+
+
+ stable
+ stable
+
+ 2007-02-17
+ PHP License
+
+* fix Bug #4475: An ambiguous error occurred when specifying similar longoption name.
+* fix Bug #10055: Not failing properly on short options missing required values
+
+
+
+
+ 1.2.1
+ 1.2.1
+
+
+ stable
+ stable
+
+ 2006-12-08
+ PHP License
+
+Fixed bugs #4448 (Long parameter values truncated with longoption parameter) and #7444 (Trailing spaces after php closing tag)
+
+
+
+
+ 1.2
+ 1.2
+
+
+ stable
+ stable
+
+ 2003-12-11
+ PHP License
+
+Fix to preserve BC with 1.0 and allow correct behaviour for new users
+
+
+
+
+ 1.0
+ 1.0
+
+
+ stable
+ stable
+
+ 2002-09-13
+ PHP License
+
+Stable release
+
+
+
+
+ 0.11
+ 0.11
+
+
+ beta
+ beta
+
+ 2002-05-26
+ PHP License
+
+POSIX getopt compatibility fix: treat first element of args
+ array as command name
+
+
+
+
+ 0.10
+ 0.10
+
+
+ beta
+ beta
+
+ 2002-05-12
+ PHP License
+
+Packaging fix
+
+
+
+
+ 0.9
+ 0.9
+
+
+ beta
+ beta
+
+ 2002-05-12
+ PHP License
+
+Initial release
+
+
+
+
+ Console_Getopt-1.4.1/Console/Getopt.php 0000644 0001750 0000144 00000032144 12553254770 017405 0 ustar cweiske users
+ * @license http://www.php.net/license/3_0.txt PHP 3.0
+ * @version CVS: $Id$
+ * @link http://pear.php.net/package/Console_Getopt
+ */
+
+require_once 'PEAR.php';
+
+/**
+ * Command-line options parsing class.
+ *
+ * @category Console
+ * @package Console_Getopt
+ * @author Andrei Zmievski
+ * @license http://www.php.net/license/3_0.txt PHP 3.0
+ * @link http://pear.php.net/package/Console_Getopt
+ */
+class Console_Getopt
+{
+
+ /**
+ * Parses the command-line options.
+ *
+ * The first parameter to this function should be the list of command-line
+ * arguments without the leading reference to the running program.
+ *
+ * The second parameter is a string of allowed short options. Each of the
+ * option letters can be followed by a colon ':' to specify that the option
+ * requires an argument, or a double colon '::' to specify that the option
+ * takes an optional argument.
+ *
+ * The third argument is an optional array of allowed long options. The
+ * leading '--' should not be included in the option name. Options that
+ * require an argument should be followed by '=', and options that take an
+ * option argument should be followed by '=='.
+ *
+ * The return value is an array of two elements: the list of parsed
+ * options and the list of non-option command-line arguments. Each entry in
+ * the list of parsed options is a pair of elements - the first one
+ * specifies the option, and the second one specifies the option argument,
+ * if there was one.
+ *
+ * Long and short options can be mixed.
+ *
+ * Most of the semantics of this function are based on GNU getopt_long().
+ *
+ * @param array $args an array of command-line arguments
+ * @param string $short_options specifies the list of allowed short options
+ * @param array $long_options specifies the list of allowed long options
+ * @param boolean $skip_unknown suppresses Console_Getopt: unrecognized option
+ *
+ * @return array two-element array containing the list of parsed options and
+ * the non-option arguments
+ */
+ public static function getopt2($args, $short_options, $long_options = null, $skip_unknown = false)
+ {
+ return Console_Getopt::doGetopt(2, $args, $short_options, $long_options, $skip_unknown);
+ }
+
+ /**
+ * This function expects $args to start with the script name (POSIX-style).
+ * Preserved for backwards compatibility.
+ *
+ * @param array $args an array of command-line arguments
+ * @param string $short_options specifies the list of allowed short options
+ * @param array $long_options specifies the list of allowed long options
+ *
+ * @see getopt2()
+ * @return array two-element array containing the list of parsed options and
+ * the non-option arguments
+ */
+ public static function getopt($args, $short_options, $long_options = null, $skip_unknown = false)
+ {
+ return Console_Getopt::doGetopt(1, $args, $short_options, $long_options, $skip_unknown);
+ }
+
+ /**
+ * The actual implementation of the argument parsing code.
+ *
+ * @param int $version Version to use
+ * @param array $args an array of command-line arguments
+ * @param string $short_options specifies the list of allowed short options
+ * @param array $long_options specifies the list of allowed long options
+ * @param boolean $skip_unknown suppresses Console_Getopt: unrecognized option
+ *
+ * @return array
+ */
+ public static function doGetopt($version, $args, $short_options, $long_options = null, $skip_unknown = false)
+ {
+ // in case you pass directly readPHPArgv() as the first arg
+ if (PEAR::isError($args)) {
+ return $args;
+ }
+
+ if (empty($args)) {
+ return array(array(), array());
+ }
+
+ $non_opts = $opts = array();
+
+ settype($args, 'array');
+
+ if ($long_options) {
+ sort($long_options);
+ }
+
+ /*
+ * Preserve backwards compatibility with callers that relied on
+ * erroneous POSIX fix.
+ */
+ if ($version < 2) {
+ if (isset($args[0]{0}) && $args[0]{0} != '-') {
+ array_shift($args);
+ }
+ }
+
+ reset($args);
+ while (list($i, $arg) = each($args)) {
+ /* The special element '--' means explicit end of
+ options. Treat the rest of the arguments as non-options
+ and end the loop. */
+ if ($arg == '--') {
+ $non_opts = array_merge($non_opts, array_slice($args, $i + 1));
+ break;
+ }
+
+ if ($arg{0} != '-' || (strlen($arg) > 1 && $arg{1} == '-' && !$long_options)) {
+ $non_opts = array_merge($non_opts, array_slice($args, $i));
+ break;
+ } elseif (strlen($arg) > 1 && $arg{1} == '-') {
+ $error = Console_Getopt::_parseLongOption(substr($arg, 2),
+ $long_options,
+ $opts,
+ $args,
+ $skip_unknown);
+ if (PEAR::isError($error)) {
+ return $error;
+ }
+ } elseif ($arg == '-') {
+ // - is stdin
+ $non_opts = array_merge($non_opts, array_slice($args, $i));
+ break;
+ } else {
+ $error = Console_Getopt::_parseShortOption(substr($arg, 1),
+ $short_options,
+ $opts,
+ $args,
+ $skip_unknown);
+ if (PEAR::isError($error)) {
+ return $error;
+ }
+ }
+ }
+
+ return array($opts, $non_opts);
+ }
+
+ /**
+ * Parse short option
+ *
+ * @param string $arg Argument
+ * @param string[] $short_options Available short options
+ * @param string[][] &$opts
+ * @param string[] &$args
+ * @param boolean $skip_unknown suppresses Console_Getopt: unrecognized option
+ *
+ * @return void
+ */
+ protected static function _parseShortOption($arg, $short_options, &$opts, &$args, $skip_unknown)
+ {
+ for ($i = 0; $i < strlen($arg); $i++) {
+ $opt = $arg{$i};
+ $opt_arg = null;
+
+ /* Try to find the short option in the specifier string. */
+ if (($spec = strstr($short_options, $opt)) === false || $arg{$i} == ':') {
+ if ($skip_unknown === true) {
+ break;
+ }
+
+ $msg = "Console_Getopt: unrecognized option -- $opt";
+ return PEAR::raiseError($msg);
+ }
+
+ if (strlen($spec) > 1 && $spec{1} == ':') {
+ if (strlen($spec) > 2 && $spec{2} == ':') {
+ if ($i + 1 < strlen($arg)) {
+ /* Option takes an optional argument. Use the remainder of
+ the arg string if there is anything left. */
+ $opts[] = array($opt, substr($arg, $i + 1));
+ break;
+ }
+ } else {
+ /* Option requires an argument. Use the remainder of the arg
+ string if there is anything left. */
+ if ($i + 1 < strlen($arg)) {
+ $opts[] = array($opt, substr($arg, $i + 1));
+ break;
+ } else if (list(, $opt_arg) = each($args)) {
+ /* Else use the next argument. */;
+ if (Console_Getopt::_isShortOpt($opt_arg)
+ || Console_Getopt::_isLongOpt($opt_arg)) {
+ $msg = "option requires an argument --$opt";
+ return PEAR::raiseError("Console_Getopt: " . $msg);
+ }
+ } else {
+ $msg = "option requires an argument --$opt";
+ return PEAR::raiseError("Console_Getopt: " . $msg);
+ }
+ }
+ }
+
+ $opts[] = array($opt, $opt_arg);
+ }
+ }
+
+ /**
+ * Checks if an argument is a short option
+ *
+ * @param string $arg Argument to check
+ *
+ * @return bool
+ */
+ protected static function _isShortOpt($arg)
+ {
+ return strlen($arg) == 2 && $arg[0] == '-'
+ && preg_match('/[a-zA-Z]/', $arg[1]);
+ }
+
+ /**
+ * Checks if an argument is a long option
+ *
+ * @param string $arg Argument to check
+ *
+ * @return bool
+ */
+ protected static function _isLongOpt($arg)
+ {
+ return strlen($arg) > 2 && $arg[0] == '-' && $arg[1] == '-' &&
+ preg_match('/[a-zA-Z]+$/', substr($arg, 2));
+ }
+
+ /**
+ * Parse long option
+ *
+ * @param string $arg Argument
+ * @param string[] $long_options Available long options
+ * @param string[][] &$opts
+ * @param string[] &$args
+ *
+ * @return void|PEAR_Error
+ */
+ protected static function _parseLongOption($arg, $long_options, &$opts, &$args, $skip_unknown)
+ {
+ @list($opt, $opt_arg) = explode('=', $arg, 2);
+
+ $opt_len = strlen($opt);
+
+ for ($i = 0; $i < count($long_options); $i++) {
+ $long_opt = $long_options[$i];
+ $opt_start = substr($long_opt, 0, $opt_len);
+
+ $long_opt_name = str_replace('=', '', $long_opt);
+
+ /* Option doesn't match. Go on to the next one. */
+ if ($long_opt_name != $opt) {
+ continue;
+ }
+
+ $opt_rest = substr($long_opt, $opt_len);
+
+ /* Check that the options uniquely matches one of the allowed
+ options. */
+ if ($i + 1 < count($long_options)) {
+ $next_option_rest = substr($long_options[$i + 1], $opt_len);
+ } else {
+ $next_option_rest = '';
+ }
+
+ if ($opt_rest != '' && $opt{0} != '=' &&
+ $i + 1 < count($long_options) &&
+ $opt == substr($long_options[$i+1], 0, $opt_len) &&
+ $next_option_rest != '' &&
+ $next_option_rest{0} != '=') {
+
+ $msg = "Console_Getopt: option --$opt is ambiguous";
+ return PEAR::raiseError($msg);
+ }
+
+ if (substr($long_opt, -1) == '=') {
+ if (substr($long_opt, -2) != '==') {
+ /* Long option requires an argument.
+ Take the next argument if one wasn't specified. */;
+ if (!strlen($opt_arg) && !(list(, $opt_arg) = each($args))) {
+ $msg = "Console_Getopt: option requires an argument --$opt";
+ return PEAR::raiseError($msg);
+ }
+
+ if (Console_Getopt::_isShortOpt($opt_arg)
+ || Console_Getopt::_isLongOpt($opt_arg)) {
+ $msg = "Console_Getopt: option requires an argument --$opt";
+ return PEAR::raiseError($msg);
+ }
+ }
+ } else if ($opt_arg) {
+ $msg = "Console_Getopt: option --$opt doesn't allow an argument";
+ return PEAR::raiseError($msg);
+ }
+
+ $opts[] = array('--' . $opt, $opt_arg);
+ return;
+ }
+
+ if ($skip_unknown === true) {
+ return;
+ }
+
+ return PEAR::raiseError("Console_Getopt: unrecognized option --$opt");
+ }
+
+ /**
+ * Safely read the $argv PHP array across different PHP configurations.
+ * Will take care on register_globals and register_argc_argv ini directives
+ *
+ * @return mixed the $argv PHP array or PEAR error if not registered
+ */
+ public static function readPHPArgv()
+ {
+ global $argv;
+ if (!is_array($argv)) {
+ if (!@is_array($_SERVER['argv'])) {
+ if (!@is_array($GLOBALS['HTTP_SERVER_VARS']['argv'])) {
+ $msg = "Could not read cmd args (register_argc_argv=Off?)";
+ return PEAR::raiseError("Console_Getopt: " . $msg);
+ }
+ return $GLOBALS['HTTP_SERVER_VARS']['argv'];
+ }
+ return $_SERVER['argv'];
+ }
+ return $argv;
+ }
+
+} Console_Getopt-1.4.1/tests/001-getopt.phpt 0000644 0001750 0000144 00000002316 12553254770 017665 0 ustar cweiske users --TEST--
+Console_Getopt
+--FILE--
+ $d) {
+ if ($i++ > 0) {
+ print ", ";
+ }
+ print $d[0] . '=' . $d[1];
+ }
+ print "\n";
+ print "params: " . implode(", ", $non_opts) . "\n";
+ print "\n";
+}
+
+test("-abc", "abc");
+test("-abc foo", "abc");
+test("-abc foo", "abc:");
+test("-abc foo bar gazonk", "abc");
+test("-abc foo bar gazonk", "abc:");
+test("-a -b -c", "abc");
+test("-a -b -c", "abc:");
+test("-abc", "ab:c");
+test("-abc foo -bar gazonk", "abc");
+?>
+--EXPECT--
+options: a=, b=, c=
+params:
+
+options: a=, b=, c=
+params: foo
+
+options: a=, b=, c=foo
+params:
+
+options: a=, b=, c=
+params: foo, bar, gazonk
+
+options: a=, b=, c=foo
+params: bar, gazonk
+
+options: a=, b=, c=
+params:
+
+Console_Getopt: option requires an argument --c
+
+options: a=, b=c
+params:
+
+options: a=, b=, c=
+params: foo, -bar, gazonk
+ Console_Getopt-1.4.1/tests/bug10557.phpt 0000644 0001750 0000144 00000000756 12553254770 017252 0 ustar cweiske users --TEST--
+Console_Getopt [bug 10557]
+--SKIPIF--
+--FILE--
+getMessage()."\n";
+ echo 'FATAL';
+ exit;
+}
+
+print_r($ret);
+?>
+--EXPECT--
+Console_Getopt: option requires an argument --to
+FATAL Console_Getopt-1.4.1/tests/bug11068.phpt 0000644 0001750 0000144 00000001431 12553254770 017237 0 ustar cweiske users --TEST--
+Console_Getopt [bug 11068]
+--SKIPIF--
+--FILE--
+getMessage()."\n";
+ echo 'FATAL';
+ exit;
+}
+
+print_r($ret);
+?>
+--EXPECT--
+Array
+(
+ [0] => Array
+ (
+ [0] => Array
+ (
+ [0] => f
+ [1] => jjohnston@mail.com
+ )
+
+ [1] => Array
+ (
+ [0] => --to
+ [1] => hi
+ )
+
+ )
+
+ [1] => Array
+ (
+ [0] => -
+ )
+
+) Console_Getopt-1.4.1/tests/bug13140.phpt 0000644 0001750 0000144 00000002505 12553254770 017233 0 ustar cweiske users --TEST--
+Console_Getopt [bug 13140]
+--SKIPIF--
+--FILE--
+getopt2($cg->readPHPArgv(), 't', array('test'), true));
+print_r($cg->getopt2($cg->readPHPArgv(), 'bar', array('foo'), true));
+?>
+--EXPECT--
+Array
+(
+ [0] => Array
+ (
+ [0] => Array
+ (
+ [0] => --test
+ [1] =>
+ )
+
+ )
+
+ [1] => Array
+ (
+ [0] => thisshouldbehere
+ )
+
+)
+Array
+(
+ [0] => Array
+ (
+ [0] => Array
+ (
+ [0] => --foo
+ [1] =>
+ )
+
+ [1] => Array
+ (
+ [0] => b
+ [1] =>
+ )
+
+ [2] => Array
+ (
+ [0] => a
+ [1] =>
+ )
+
+ [3] => Array
+ (
+ [0] => r
+ [1] =>
+ )
+
+ [4] => Array
+ (
+ [0] => r
+ [1] =>
+ )
+
+ )
+
+ [1] => Array
+ (
+ [0] => thisshouldbehere
+ )
+
+)
+ package.xml 0000644 0001750 0000144 00000147734 12610427353 012567 0 ustar cweiske users
+
+ PEAR
+ pear.php.net
+ PEAR Base System
+ The PEAR package contains:
+ * the PEAR installer, for creating, distributing
+ and installing packages
+ * the PEAR_Exception PHP5 error handling mechanism
+ * the PEAR_ErrorStack advanced error handling mechanism
+ * the PEAR_Error error handling mechanism
+ * the OS_Guess class for retrieving info about the OS
+ where PHP is running on
+ * the System class for quick handling of common operations
+ with files and directories
+ * the PEAR base class
+ Features in a nutshell:
+ * full support for channels
+ * pre-download dependency validation
+ * new package.xml 2.0 format allows tremendous flexibility while maintaining BC
+ * support for optional dependency groups and limited support for sub-packaging
+ * robust dependency support
+ * full dependency validation on uninstall
+ * remote install for hosts with only ftp access - no more problems with
+ restricted host installation
+ * full support for mirroring
+ * support for bundling several packages into a single tarball
+ * support for static dependencies on a url-based package
+ * support for custom file roles and installation tasks
+
+ Greg Beaver
+ cellog
+ cellog@php.net
+ no
+
+
+ Pierre-Alain Joye
+ pajoye
+ pierre@php.net
+ no
+
+
+ Stig Bakken
+ ssb
+ stig@php.net
+ no
+
+
+ Tomas V.V.Cox
+ cox
+ cox@idecnet.com
+ no
+
+
+ Helgi Thormar
+ dufuz
+ dufuz@php.net
+ no
+
+
+ Christian Weiske
+ cweiske
+ cweiske@php.net
+ yes
+
+
+ Tias Guns
+ tias
+ tias@php.net
+ no
+
+
+ Tim Jackson
+ timj
+ timj@php.net
+ no
+
+
+ Bertrand Gugger
+ toggg
+ toggg@php.net
+ no
+
+
+ Martin Jansen
+ mj
+ mj@php.net
+ no
+
+ 2015-10-17
+
+
+ 1.10.1
+ 1.10.1
+
+
+ stable
+ stable
+
+ New BSD License
+
+* Fix bug #20959: Crash on channel discovery with channel.xml redirect [cweiske]
+* Fix bug #20968: Incorrect call to __construct() from PEAR() [edlman]
+* Add legacy constructor for PEAR_Error for backwards compatibility [cweiske]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 5.4.0
+
+
+ 1.9.0
+
+
+ Archive_Tar
+ pear.php.net
+ 1.4.0
+
+
+ Structures_Graph
+ pear.php.net
+ 1.1.0
+ 1.1.1
+
+
+ Console_Getopt
+ pear.php.net
+ 1.4.1
+ 1.4.1
+
+
+ XML_Util
+ pear.php.net
+ 1.3.0
+ 1.3.0
+
+
+ PEAR_Frontend_Web
+ pear.php.net
+ 0.4
+
+
+
+ PEAR_Frontend_Gtk
+ pear.php.net
+ 0.4.0
+ 0.4.0
+
+
+
+ xml
+
+
+ pcre
+
+
+
+
+ PEAR_Frontend_Web
+ pear.php.net
+ 0.5.1
+
+
+
+
+ PEAR_Frontend_Gtk
+ pear.php.net
+ 0.4.0
+
+
+
+
+ PEAR_Frontend_Gtk2
+ pear.php.net
+
+
+
+
+
+
+ windows
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1.8.0alpha1
+ 1.8.0
+
+
+ alpha
+ stable
+
+ 2009-03-09
+ New BSD License
+
+* Implement Request #10373: if pref_state=stable and installed package=beta, allow up to latest beta version [dufuz]
+* Implement Request #10581: login / logout should map to channel-login / channel-logout [dufuz]
+* Implement Request #10825: Only display the "invalid or missing package file"-error if it makes sense [dufuz]
+* Implement Request #11170: script to generate Command/[command].xml [dufuz]
+* Implement Request #11176: improve channel ... has updated its protocols message [dufuz]
+* Implement Request #12706: pear list -a hard to read [dufuz]
+* Implement Request #11353: upgrade-all and upgrade commands to upgrade within the same stability level [dufuz]
+* Implement Request #13015: Add https discovery for channel.xml [dufuz / initial patch by Martin Roos]
+* Implement Request #13927: install-pear.php should have option to set www_dir [timj]
+* Implement Request #14324: Make the pear install command behave similar to apt-get [dufuz]
+* Implement Request #14325: make pear upgrade with no params behave like pear upgrade-all [dufuz]
+ - upgrade-all can be considered deprecated in favor of calling upgrade with no parameters to replicate
+ better what other package managers are doing. upgrade-all will still work as intended.
+* Implement Request #14504: add a channel parameter support to the upgrade function [dufuz]
+ - Options -c ezc and --channel=ezc got added to upgrade and upgrade-all to allow for
+ channel specific upgrades
+* Implement Request #14556: install-pear-nozlib.phar should get download_dir config and other options [cweiske]
+* Implement Request #15566: Add doc.php.net as a default channel [dufuz / saltybeagle]
+
+* Fix PHP Bug #43857: --program-suffix not always reflected everywhere [cellog]
+* Fix PHP Bug #47323: strotime warnings in make install [dufuz]
+
+* Fix Bug #13908: pear info command and maintainers inactive not mentioned [dufuz]
+* Fix Bug #13926: install-pear.php does not set cfg_dir if -d option set with no -c option [timj]
+* Fix Bug #13943: tests fail when php.exe path contains spaces [dufuz / jorrit]
+* Fix Bug #13953: config-set/config-show with channel alias fail [cellog]
+* Fix Bug #13958: When a phpt tests exit() or die() xdebug coverage is not generated, patch by izi (David Jean Louis) [izi / dufuz]
+* Fix Bug #14041: Unpredictable unit test processing sequence [dufuz]
+* Fix Bug #14140: Strict warning not suppressed in the shutdown function [dufuz]
+* Fix Bug #14210: pear list -ia brings warnings [dufuz]
+* Fix Bug #14274: PEAR packager mangles package.xml encoding, then complains about it [dufuz]
+* Fix Bug #14287: cannot upgrade from stable to beta via -beta when config is set to stable [dufuz]
+* Fix Bug #14300: Package files themselves can not be served over https [dufuz / initial patch by Martin Roos]
+* Fix Bug #14437: openbasedir warning when loading config [dufuz]
+* Fix Bug #14558: PackageFile.php creates tmp directory outside configured temp_dir [cweiske]
+* Fix Bug #14947: downloadHttp() is missing Host part of the HTTP Request when using Proxy [ifeghali]
+* Fix Bug #14977: PEAR/Frontend.php doesn't require_once PEAR.php [dufuz]
+* Fix Bug #15750: Unreachable code in PEAR_Downloader [dufuz]
+* Fix Bug #15979: Package files incorrectly removed when splitting a package into multiple pkgs [dufuz]
+* Fix Bug #15914: pear upgrade installs different version if desired version not found [dufuz]
+
+NOTE!
+Functions that have been deprecated for 3+ years in PEAR_Common, please take a moment
+to migrate over to one of the alternatives that have ben provided:
+* PEAR_Common->downloadHttp (use PEAR_Downloader->downloadHttp instead)
+* PEAR_Common->infoFromTgzFile (use PEAR_PackageFile->fromTgzFile instead)
+* PEAR_Common->infoFromDescriptionFile (use PEAR_PackageFile->fromPackageFile instead)
+* PEAR_Common->infoFromString (use PEAR_PackageFile->fromXmlstring instead)
+* PEAR_Common->infoFromArray (use PEAR_PackageFile->fromAnyFile instead)
+* PEAR_Common->xmlFromInfo (use a PEAR_PackageFile_v* object's generator instead)
+* PEAR_Common->validatePackageInfo (use the validation of PEAR_PackageFile objects)
+* PEAR_Common->analyzeSourceCode (use a PEAR_PackageFile_v* object instead)
+* PEAR_Common->detectDependencies (use PEAR_Downloader_Package->detectDependencies instead)
+* PEAR_Common->buildProvidesArray (use PEAR_PackageFile_v1->_buildProvidesArray or
+ PEAR_PackageFile_v2_Validator->_buildProvidesArray)
+
+PHP 4.4 and 5.1.6 are now the minimum PHP requirements, for brave souls
+pear upgrade -f PEAR will allow people with lower versions
+to upgrade to this release but no guarantees will be made that it will work properly.
+
+Support for XML RPC channels has been dropped - The only ones that used it
+(pear.php.net and pecl.php.net) have used the REST interface for years now.
+SOAP support also removed as it was only proof of concept.
+
+Move codebase from the PHP License to New BSD 2 clause license
+
+
+
+ 2009-03-27
+
+ 1.8.0RC1
+ 1.8.0
+
+
+ beta
+ stable
+
+ New BSD License
+
+* Fix Bug #14331: pear cvstag only works from inside the package directory [dufuz]
+* Fix Bug #16045: E_Notice: Undefined index: channel in PEAR/DependencyDB.php [dufuz]
+
+* Implemented Request #11230: better error message when mirror not in channel.xml file [dufuz]
+* Implemented Request #13150: Add support for following HTTP 302 redirects [dufuz]
+
+
+
+ 2009-04-10
+
+ 1.8.0
+ 1.8.0
+
+
+ stable
+ stable
+
+ New BSD License
+
+Changes since RC1:
+ * Fix Bug #14792: Bad md5sum for files with replaced content [dufuz]
+ * Fix Bug #16057:-r is limited to 4 directories in depth [dufuz]
+ * Fix Bug #16077: PEAR5::getStaticProperty does not return a reference to the property [dufuz]
+
+ Remove custom XML_Util class in favor of using upstream XML_Util package as dependency
+
+RC1 Release Notes:
+ * Fix Bug #14331: pear cvstag only works from inside the package directory [dufuz]
+ * Fix Bug #16045: E_Notice: Undefined index: channel in PEAR/DependencyDB.php [dufuz]
+
+ * Implemented Request #11230: better error message when mirror not in channel.xml file [dufuz]
+ * Implemented Request #13150: Add support for following HTTP 302 redirects [dufuz]
+
+Alpha1 Release Notes:
+ * Implement Request #10373: if pref_state=stable and installed package=beta, allow up to latest beta version [dufuz]
+ * Implement Request #10581: login / logout should map to channel-login / channel-logout [dufuz]
+ * Implement Request #10825: Only display the "invalid or missing package file"-error if it makes sense [dufuz]
+ * Implement Request #11170: script to generate Command/[command].xml [dufuz]
+ * Implement Request #11176: improve channel ... has updated its protocols message [dufuz]
+ * Implement Request #12706: pear list -a hard to read [dufuz]
+ * Implement Request #11353: upgrade-all and upgrade commands to upgrade within the same stability level [dufuz]
+ * Implement Request #13015: Add https discovery for channel.xml [dufuz / initial patch by Martin Roos]
+ * Implement Request #13927: install-pear.php should have option to set www_dir [timj]
+ * Implement Request #14324: Make the pear install command behave similar to apt-get [dufuz]
+ * Implement Request #14325: make pear upgrade with no params behave like pear upgrade-all [dufuz]
+ - upgrade-all can be considered deprecated in favor of calling upgrade with no parameters to replicate
+ better what other package managers are doing. upgrade-all will still work as intended.
+ * Implement Request #14504: add a channel parameter support to the upgrade function [dufuz]
+ - Options -c ezc and --channel=ezc got added to upgrade and upgrade-all to allow for
+ channel specific upgrades
+ * Implement Request #14556: install-pear-nozlib.phar should get download_dir config and other options [cweiske]
+ * Implement Request #15566: Add doc.php.net as a default channel [dufuz / saltybeagle]
+
+ * Fix PHP Bug #43857: --program-suffix not always reflected everywhere [cellog]
+ * Fix PHP Bug #47323: strotime warnings in make install [dufuz]
+
+ * Fix Bug #13908: pear info command and maintainers inactive not mentioned [dufuz]
+ * Fix Bug #13926: install-pear.php does not set cfg_dir if -d option set with no -c option [timj]
+ * Fix Bug #13943: tests fail when php.exe path contains spaces [dufuz / jorrit]
+ * Fix Bug #13953: config-set/config-show with channel alias fail [cellog]
+ * Fix Bug #13958: When a phpt tests exit() or die() xdebug coverage is not generated, patch by izi (David Jean Louis) [izi / dufuz]
+ * Fix Bug #14041: Unpredictable unit test processing sequence [dufuz]
+ * Fix Bug #14140: Strict warning not suppressed in the shutdown function [dufuz]
+ * Fix Bug #14210: pear list -ia brings warnings [dufuz]
+ * Fix Bug #14274: PEAR packager mangles package.xml encoding, then complains about it [dufuz]
+ * Fix Bug #14287: cannot upgrade from stable to beta via -beta when config is set to stable [dufuz]
+ * Fix Bug #14300: Package files themselves can not be served over https [dufuz / initial patch by Martin Roos]
+ * Fix Bug #14437: openbasedir warning when loading config [dufuz]
+ * Fix Bug #14558: PackageFile.php creates tmp directory outside configured temp_dir [cweiske]
+ * Fix Bug #14947: downloadHttp() is missing Host part of the HTTP Request when using Proxy [ifeghali]
+ * Fix Bug #14977: PEAR/Frontend.php doesn't require_once PEAR.php [dufuz]
+ * Fix Bug #15750: Unreachable code in PEAR_Downloader [dufuz]
+ * Fix Bug #15979: Package files incorrectly removed when splitting a package into multiple pkgs [dufuz]
+ * Fix Bug #15914: pear upgrade installs different version if desired version not found [dufuz]
+
+ NOTE!
+ Functions that have been deprecated for 3+ years in PEAR_Common, please take a moment
+ to migrate over to one of the alternatives that have ben provided:
+ * PEAR_Common->downloadHttp (use PEAR_Downloader->downloadHttp instead)
+ * PEAR_Common->infoFromTgzFile (use PEAR_PackageFile->fromTgzFile instead)
+ * PEAR_Common->infoFromDescriptionFile (use PEAR_PackageFile->fromPackageFile instead)
+ * PEAR_Common->infoFromString (use PEAR_PackageFile->fromXmlstring instead)
+ * PEAR_Common->infoFromArray (use PEAR_PackageFile->fromAnyFile instead)
+ * PEAR_Common->xmlFromInfo (use a PEAR_PackageFile_v* object's generator instead)
+ * PEAR_Common->validatePackageInfo (use the validation of PEAR_PackageFile objects)
+ * PEAR_Common->analyzeSourceCode (use a PEAR_PackageFile_v* object instead)
+ * PEAR_Common->detectDependencies (use PEAR_Downloader_Package->detectDependencies instead)
+ * PEAR_Common->buildProvidesArray (use PEAR_PackageFile_v1->_buildProvidesArray or
+ PEAR_PackageFile_v2_Validator->_buildProvidesArray)
+
+ PHP 4.4 and 5.1.6 are now the minimum PHP requirements, for brave souls
+ pear upgrade -f PEAR will allow people with lower versions
+ to upgrade to this release but no guarantees will be made that it will work properly.
+
+ Support for XML RPC channels has been dropped - The only ones that used it
+ (pear.php.net and pecl.php.net) have used the REST interface for years now.
+ SOAP support also removed as it was only proof of concept.
+
+ Move codebase from the PHP License to New BSD 2 clause license
+
+
+
+ 2009-04-15
+
+ 1.8.1
+ 1.8.1
+
+
+ stable
+ stable
+
+ New BSD License
+
+* Fix Bug #16099 PEAR crash on PHP4 (parse error) [dufuz]
+
+
+
+ 2009-08-18
+
+ 1.9.0RC1
+ 1.9.0RC1
+
+
+ beta
+ stable
+
+ New BSD License
+
+* Implement Request #16213: add alias to list-channels output [dufuz]
+* Implement Request #16378: pear svntag [dufuz]
+* Implement Request #16386: PEAR_Config::remove() does not support specifying a channel [timj]
+* Implement Request #16396: package-dependencies should allow package names [dufuz]
+
+* Fix Bug #11181: pear requests channel.xml from main server instead from mirror [dufuz]
+* Fix Bug #14493: pear install --offline doesn't print out errors [dufuz]
+* Fix Bug #11348: pear package-dependencies isn't well explained [dufuz]
+* Fix Bug #16108: PEAR_PackageFile_Generator_v2 PHP4 parse error when running upgrade-all [dufuz]
+* Fix Bug #16113: Installing certain packages fails due incorrect encoding handling [dufuz]
+* Fix Bug #16122: PEAR RunTest failed to run as expected [dufuz]
+* Fix Bug #16366: compiling 5.2.10 leads to non-functioning pear [dufuz]
+* Fix Bug #16387: channel-logout does not support logging out from a non-default channel [timj]
+* Fix Bug #16444: Setting preferred mirror fails [dufuz]
+* Fix the shutdown functions where a index might not exist and thus raise a notice [derick]
+
+
+
+ 2009-08-20
+
+ 1.9.0RC2
+ 1.9.0RC2
+
+
+ beta
+ stable
+
+ New BSD License
+
+* REST 1.4 file was occasionally being included but REST 1.4 is not intended for this release cycle [dufuz]
+
+
+
+ 2009-08-21
+
+ 1.9.0RC3
+ 1.9.0RC3
+
+
+ beta
+ stable
+
+ New BSD License
+
+* Improved svntag support to handle packages like PEAR it self [dufuz]
+
+
+
+ 2009-08-23
+
+ 1.9.0RC4
+ 1.9.0RC4
+
+
+ beta
+ stable
+
+ New BSD License
+
+* Fixed a problem where the original channel could not be set as a preferred_mirror again [dufuz]
+* Make sure channel aliases can't be made to start with - [dufuz]
+* Output issues with pear search [dufuz]
+* Fixed couple of stray notices [dufuz]
+
+
+
+ 2009-09-03
+
+ 1.9.0
+ 1.9.0
+
+
+ stable
+ stable
+
+ New BSD License
+
+* Fix Bug #16547: The phar for PEAR installer uses ereg() which is deprecated [dufuz]
+
+
+
+ 2010-05-26
+
+ 1.9.1
+ 1.9.1
+
+
+ stable
+ stable
+
+ New BSD License
+
+* svntag improvements, tag package files passed into the command and better directory checks [dufuz]
+* rely on Structures_Graph minimum version instead of recommended version [saltybeagle]
+* Fix Bug #12613: running go-pear.phar from C:\ fails [dufuz]
+* Fix Bug #14841: Installing pear into directory with space fails [dufuz]
+* Fix Bug #16644: pear.bat returns syntax error when parenthesis are in install path. [dufuz] [patch by bwaters (Bryan Waters)]
+* Fix Bug #16767: Use of Depreciated HTML Attributes in the Exception class [dufuz] [patch by fuhrysteve (Stephen J. Fuhry)]
+* Fix Bug #16864: "pear list-upgrades -i" issues E_WARNINGS [dufuz] [patch by rquadling (Richard Quadling)]
+* Fix Bug #17220: command `pear help` outputs to stderr instead of stdout [dufuz]
+* Fix Bug #17234: channel-discover adds port to HTTP Host header [dufuz]
+* Fix Bug #17292: Code Coverage in PEAR_RunTest does not work with namespaces [sebastian]
+* Fix Bug #17359: loadExtension() fails over missing dl() when used in multithread env [dufuz]
+* Fix Bug #17378: pear info $package fails if directory with that name exists [dufuz]
+
+
+
+ 2011-02-28
+
+
+ 1.9.2
+ 1.9.2
+
+
+ stable
+ stable
+
+ New BSD License
+
+Important! This is a security fix release. The advisory can be found at
+http://pear.php.net/advisory-20110228.txt
+
+ Bugs:
+ * Fixed Bug #17463: Regression: On Windows, svntag [patch by doconnor]
+ * Fixed Bug #17641: pecl-list doesn't sort packages by name [dufuz]
+ * Fixed Bug #17781: invalid argument warning on foreach due to an empty optional dependencie [dufuz]
+ * Fixed Bug #17801: PEAR run-tests wrongly detects php-cgi [patch by David Jean Louis (izi)]
+ * Fixed Bug #17839: pear svntag does not tag package.xml file [dufuz]
+ * Fixed Bug #17986: PEAR Installer cannot handle files moved between packages [dufuz]
+ * Fixed Bug #17997: Strange output if directories are not writeable [dufuz]
+ * Fixed Bug #18001: PEAR/RunTest coverage fails [dufuz]
+ * Fixed Bug #18056 [SECURITY]: Symlink attack in PEAR install [dufuz]
+ * Fixed Bug #18218: "pear package" does not allow the use of late static binding [dufuz and Christer Edvartsen]
+ * Fixed Bug #18238: Wrong return code from "pear help" [till]
+ * Fixed Bug #18308: Broken error message about missing channel validator [yunosh]
+
+ This feature is implemented as a result of #18056
+ * Implemented Request #16648: Use TMPDIR for builds instead of /var/tmp [dufuz]
+
+
+
+ 2011-06-04
+
+
+ 1.9.3
+ 1.9.2
+
+
+ stable
+ stable
+
+ New BSD License
+
+* Fixed Bug #17744: Empty changelog causes fatal error in setChangelogentry [dufuz]
+* Fixed Bug #18340: raiseErro typo [doconnor]
+* Fixed Bug #18349: package.xml version not recognized when single quoted [dufuz]
+* Fixed Bug #18364: date.timezone errors for sh/bat files when TZ is not set in php.ini [dufuz]
+* Fixed Bug #18388: Parentheses error in REST.php line 232 [dufuz]
+* Fixed Bug #18428: invalid preg_match patterns [glen]
+* Fixed Bug #18486: REST/10.php does not check error condition [dufuz]
+* Fixed a problem in RunTest and code coverage. Correctly register the
+ code coverage shutdown function in case we are inside a namespace. [sebastian]
+* Fixed a bug with extensions not providing their config.m4 and co in the root directory of
+ their pecl package but rather in a sub directory, such as xhprof. [dufuz]
+
+
+
+ 2011-07-06
+
+
+ 1.9.4
+ 1.9.4
+
+
+ stable
+ stable
+
+ New BSD License
+
+Bug Fixes:
+* Bug #17350: "pear install --force" doesn't uninstall files from previous pkg versions [dufuz]
+* Bug #18362: A whitespace TEMP_DIR path breaks install/upgrade functionality [dufuz]
+* Bug #18440: bad tmp folder path on install : Unable to create path for C:/Program/tmp [dufuz]
+* Bug #18581: "config-get -c" not returning channel's configuration when using alias [dufuz]
+* Bug #18639: regression: installing xdebug fails most likely due to another fix [dufuz]
+
+Features
+* All System (the class) functions can now take in spaced paths as long as they are surrounded in quotes.
+ Prior to this it was possible to do that by passing all values in as an array (by product of #18362, #18440) [dufuz]
+
+
+
+ 2014-06-27
+
+
+ 1.9.5dev1
+ 1.9.5
+
+
+ devel
+ devel
+
+ New BSD License
+
+Bug fixes:
+* Fix bug #18343: Entities in file names decoded during packaging [cweiske]
+* Fix bug #18665: pecl extensions not enabled in empty php.ini files [Louis Opter]
+* Fix bug #18834: Do not truncate cache file if it is a symlink [avb]
+* Fix bug #18892: Parse error in Installer.php [ashnazg]
+* Fix bug #19482: fix pearcmd for include paths with trailing backslash [cweiske]
+* Fix bug #19793: PHP Notice about ob_end_clean() [cweiske]
+* Fix bug #20086: Invalid regexp in PEAR_Builder::build() [avb]
+* Fix bug #20203: split content-type and get real mime type [Samu Voutilainen]
+* Fix bug #20283: use full path for "zend_extension=..." [cweiske]
+* Fix bug #20284: Reset interpreter before running --CLEAN-- section php-cgi run [Mats Lindh]
+* Fix bug #20285: fix spelling mistakes [Veres Lajos]
+* Fix bug #20286: Support access of static variables on objects in validator [cweiske]
+* Fix bug #20321: Correctly detect name of current user during installation [cweiske]
+* Fix bug: let pear run-tests fail when there are failed tests [cweiske]
+* Prepare a test for bug #18056 / bug #18834 [avb]
+
+
+
+ 2014-07-12
+
+
+ 1.9.5
+ 1.9.5
+
+
+ stable
+ stable
+
+ New BSD License
+
+No changes since 1.9.5.dev1.
+
+Bug fixes in 1.9.5.dev1:
+* Fix bug #18343: Entities in file names decoded during packaging [cweiske]
+* Fix bug #18665: pecl extensions not enabled in empty php.ini files [Louis Opter]
+* Fix bug #18834: Do not truncate cache file if it is a symlink [avb]
+* Fix bug #18892: Parse error in Installer.php [ashnazg]
+* Fix bug #19482: fix pearcmd for include paths with trailing backslash [cweiske]
+* Fix bug #19793: PHP Notice about ob_end_clean() [cweiske]
+* Fix bug #20086: Invalid regexp in PEAR_Builder::build() [avb]
+* Fix bug #20203: split content-type and get real mime type [Samu Voutilainen]
+* Fix bug #20283: use full path for "zend_extension=..." [cweiske]
+* Fix bug #20284: Reset interpreter before running --CLEAN-- section php-cgi run [Mats Lindh]
+* Fix bug #20285: fix spelling mistakes [Veres Lajos]
+* Fix bug #20286: Support access of static variables on objects in validator [cweiske]
+* Fix bug #20321: Correctly detect name of current user during installation [cweiske]
+* Fix bug: let pear run-tests fail when there are failed tests [cweiske]
+* Prepare a test for bug #18056 / bug #18834 [avb]
+
+
+
+ 2015-07-25
+
+
+ 1.10.0dev1
+ 1.10.0
+
+
+ devel
+ devel
+
+ New BSD License
+
+* Implement #20488: Add support for PHP 7 [cweiske]
+* Drop support for PHP 4 and 5.0 - 5.3 [cweiske]
+* Remove deprecated methods [cweiske]
+* Fix static warnings [cweiske]
+* Fix #17045: avoid overwriting include path [glen]
+* Fix #17399: "pear help" doesn't mention the "version" command [kguest]
+* Add --showdiff to "pear run-tests" to print diff for failed tests [tyrael]
+* Fix channel.xml downloading from https if it did not change [cweiske]
+
+
+
+ 2015-07-31
+
+
+ 1.10.0dev2
+ 1.10.0
+
+
+ devel
+ devel
+
+ New BSD License
+
+* Fix #18638 and #18405: Make PEAR::loadExtension static [cweiske]
+* Fix #20319: allow pear to work when cache_dir is not writable [remicollet]
+* Implement #20333: New role=man for man pages [bjori]
+* Implement #20334: add "metadata_dir" configuration option [remicollet]
+* Add long option names to install-pear.php [remicollet]
+
+
+
+ 2015-09-28
+
+
+ 1.10.0dev3
+ 1.10.0
+
+
+ devel
+ devel
+
+ New BSD License
+
+* Fix #20507: pear list-upgrades does not take PHP version into account [cweiske]
+* Fix #20927: Use correct php-config [cweiske]
+* Fix #20946: PEAR_Builder::log() declaration [remicollet]
+* Remove PEAR/ErrorStack5.php [cweiske]
+
+
+
+ 2015-10-07
+
+
+ 1.10.0
+ 1.10.0
+
+
+ stable
+ stable
+
+ New BSD License
+
+No changes since version 1.10.0dev3.
+
+Changes since version 1.9.5:
+* Implement #20488: Add support for PHP 7 [cweiske]
+* Drop support for PHP 4 and 5.0 - 5.3 [cweiske]
+* Remove deprecated methods [cweiske]
+* Add --showdiff to "pear run-tests" to print diff for failed tests [tyrael]
+* Implement #20333: New role=man for man pages [bjori]
+* Implement #20334: add "metadata_dir" configuration option [remicollet]
+* Add long option names to install-pear.php [remicollet]
+* Remove PEAR/ErrorStack5.php [cweiske]
+* Fix #17045: avoid overwriting include path [glen]
+* Fix #17399: "pear help" doesn't mention the "version" command [kguest]
+* Fix #18638 and #18405: Make PEAR::loadExtension static [cweiske]
+* Fix #20319: allow pear to work when cache_dir is not writable [remicollet]
+* Fix #20507: pear list-upgrades does not take PHP version into account [cweiske]
+* Fix #20927: Use correct php-config [cweiske]
+* Fix #20946: PEAR_Builder::log() declaration [remicollet]
+* Fix channel.xml downloading from https if it did not change [cweiske]
+* Fix static warnings [cweiske]
+
+
+
+ 2015-10-17
+
+
+ 1.10.1
+ 1.10.1
+
+
+ stable
+ stable
+
+ New BSD License
+
+* Fix bug #20959: Crash on channel discovery with channel.xml redirect [cweiske]
+* Fix bug #20968: Incorrect call to __construct() from PEAR() [edlman]
+* Add legacy constructor for PEAR_Error for backwards compatibility [cweiske]
+
+
+
+
+ PEAR-1.10.1/OS/Guess.php 0000644 0001750 0000144 00000024532 12610427352 014022 0 ustar cweiske users
+ * @author Gregory Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since PEAR 0.1
+ */
+
+// {{{ uname examples
+
+// php_uname() without args returns the same as 'uname -a', or a PHP-custom
+// string for Windows.
+// PHP versions prior to 4.3 return the uname of the host where PHP was built,
+// as of 4.3 it returns the uname of the host running the PHP code.
+//
+// PC RedHat Linux 7.1:
+// Linux host.example.com 2.4.2-2 #1 Sun Apr 8 20:41:30 EDT 2001 i686 unknown
+//
+// PC Debian Potato:
+// Linux host 2.4.17 #2 SMP Tue Feb 12 15:10:04 CET 2002 i686 unknown
+//
+// PC FreeBSD 3.3:
+// FreeBSD host.example.com 3.3-STABLE FreeBSD 3.3-STABLE #0: Mon Feb 21 00:42:31 CET 2000 root@example.com:/usr/src/sys/compile/CONFIG i386
+//
+// PC FreeBSD 4.3:
+// FreeBSD host.example.com 4.3-RELEASE FreeBSD 4.3-RELEASE #1: Mon Jun 25 11:19:43 EDT 2001 root@example.com:/usr/src/sys/compile/CONFIG i386
+//
+// PC FreeBSD 4.5:
+// FreeBSD host.example.com 4.5-STABLE FreeBSD 4.5-STABLE #0: Wed Feb 6 23:59:23 CET 2002 root@example.com:/usr/src/sys/compile/CONFIG i386
+//
+// PC FreeBSD 4.5 w/uname from GNU shellutils:
+// FreeBSD host.example.com 4.5-STABLE FreeBSD 4.5-STABLE #0: Wed Feb i386 unknown
+//
+// HP 9000/712 HP-UX 10:
+// HP-UX iq B.10.10 A 9000/712 2008429113 two-user license
+//
+// HP 9000/712 HP-UX 10 w/uname from GNU shellutils:
+// HP-UX host B.10.10 A 9000/712 unknown
+//
+// IBM RS6000/550 AIX 4.3:
+// AIX host 3 4 000003531C00
+//
+// AIX 4.3 w/uname from GNU shellutils:
+// AIX host 3 4 000003531C00 unknown
+//
+// SGI Onyx IRIX 6.5 w/uname from GNU shellutils:
+// IRIX64 host 6.5 01091820 IP19 mips
+//
+// SGI Onyx IRIX 6.5:
+// IRIX64 host 6.5 01091820 IP19
+//
+// SparcStation 20 Solaris 8 w/uname from GNU shellutils:
+// SunOS host.example.com 5.8 Generic_108528-12 sun4m sparc
+//
+// SparcStation 20 Solaris 8:
+// SunOS host.example.com 5.8 Generic_108528-12 sun4m sparc SUNW,SPARCstation-20
+//
+// Mac OS X (Darwin)
+// Darwin home-eden.local 7.5.0 Darwin Kernel Version 7.5.0: Thu Aug 5 19:26:16 PDT 2004; root:xnu/xnu-517.7.21.obj~3/RELEASE_PPC Power Macintosh
+//
+// Mac OS X early versions
+//
+
+// }}}
+
+/* TODO:
+ * - define endianness, to allow matchSignature("bigend") etc.
+ */
+
+/**
+ * Retrieves information about the current operating system
+ *
+ * This class uses php_uname() to grok information about the current OS
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Gregory Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class OS_Guess
+{
+ var $sysname;
+ var $nodename;
+ var $cpu;
+ var $release;
+ var $extra;
+
+ function __construct($uname = null)
+ {
+ list($this->sysname,
+ $this->release,
+ $this->cpu,
+ $this->extra,
+ $this->nodename) = $this->parseSignature($uname);
+ }
+
+ function parseSignature($uname = null)
+ {
+ static $sysmap = array(
+ 'HP-UX' => 'hpux',
+ 'IRIX64' => 'irix',
+ );
+ static $cpumap = array(
+ 'i586' => 'i386',
+ 'i686' => 'i386',
+ 'ppc' => 'powerpc',
+ );
+ if ($uname === null) {
+ $uname = php_uname();
+ }
+ $parts = preg_split('/\s+/', trim($uname));
+ $n = count($parts);
+
+ $release = $machine = $cpu = '';
+ $sysname = $parts[0];
+ $nodename = $parts[1];
+ $cpu = $parts[$n-1];
+ $extra = '';
+ if ($cpu == 'unknown') {
+ $cpu = $parts[$n - 2];
+ }
+
+ switch ($sysname) {
+ case 'AIX' :
+ $release = "$parts[3].$parts[2]";
+ break;
+ case 'Windows' :
+ switch ($parts[1]) {
+ case '95/98':
+ $release = '9x';
+ break;
+ default:
+ $release = $parts[1];
+ break;
+ }
+ $cpu = 'i386';
+ break;
+ case 'Linux' :
+ $extra = $this->_detectGlibcVersion();
+ // use only the first two digits from the kernel version
+ $release = preg_replace('/^([0-9]+\.[0-9]+).*/', '\1', $parts[2]);
+ break;
+ case 'Mac' :
+ $sysname = 'darwin';
+ $nodename = $parts[2];
+ $release = $parts[3];
+ if ($cpu == 'Macintosh') {
+ if ($parts[$n - 2] == 'Power') {
+ $cpu = 'powerpc';
+ }
+ }
+ break;
+ case 'Darwin' :
+ if ($cpu == 'Macintosh') {
+ if ($parts[$n - 2] == 'Power') {
+ $cpu = 'powerpc';
+ }
+ }
+ $release = preg_replace('/^([0-9]+\.[0-9]+).*/', '\1', $parts[2]);
+ break;
+ default:
+ $release = preg_replace('/-.*/', '', $parts[2]);
+ break;
+ }
+
+ if (isset($sysmap[$sysname])) {
+ $sysname = $sysmap[$sysname];
+ } else {
+ $sysname = strtolower($sysname);
+ }
+ if (isset($cpumap[$cpu])) {
+ $cpu = $cpumap[$cpu];
+ }
+ return array($sysname, $release, $cpu, $extra, $nodename);
+ }
+
+ function _detectGlibcVersion()
+ {
+ static $glibc = false;
+ if ($glibc !== false) {
+ return $glibc; // no need to run this multiple times
+ }
+ $major = $minor = 0;
+ include_once "System.php";
+ // Use glibc's header file to
+ // get major and minor version number:
+ if (@file_exists('/usr/include/features.h') &&
+ @is_readable('/usr/include/features.h')) {
+ if (!@file_exists('/usr/bin/cpp') || !@is_executable('/usr/bin/cpp')) {
+ $features_file = fopen('/usr/include/features.h', 'rb');
+ while (!feof($features_file)) {
+ $line = fgets($features_file, 8192);
+ if (!$line || (strpos($line, '#define') === false)) {
+ continue;
+ }
+ if (strpos($line, '__GLIBC__')) {
+ // major version number #define __GLIBC__ version
+ $line = preg_split('/\s+/', $line);
+ $glibc_major = trim($line[2]);
+ if (isset($glibc_minor)) {
+ break;
+ }
+ continue;
+ }
+
+ if (strpos($line, '__GLIBC_MINOR__')) {
+ // got the minor version number
+ // #define __GLIBC_MINOR__ version
+ $line = preg_split('/\s+/', $line);
+ $glibc_minor = trim($line[2]);
+ if (isset($glibc_major)) {
+ break;
+ }
+ continue;
+ }
+ }
+ fclose($features_file);
+ if (!isset($glibc_major) || !isset($glibc_minor)) {
+ return $glibc = '';
+ }
+ return $glibc = 'glibc' . trim($glibc_major) . "." . trim($glibc_minor) ;
+ } // no cpp
+
+ $tmpfile = System::mktemp("glibctest");
+ $fp = fopen($tmpfile, "w");
+ fwrite($fp, "#include \n__GLIBC__ __GLIBC_MINOR__\n");
+ fclose($fp);
+ $cpp = popen("/usr/bin/cpp $tmpfile", "r");
+ while ($line = fgets($cpp, 1024)) {
+ if ($line{0} == '#' || trim($line) == '') {
+ continue;
+ }
+
+ if (list($major, $minor) = explode(' ', trim($line))) {
+ break;
+ }
+ }
+ pclose($cpp);
+ unlink($tmpfile);
+ } // features.h
+
+ if (!($major && $minor) && @is_link('/lib/libc.so.6')) {
+ // Let's try reading the libc.so.6 symlink
+ if (preg_match('/^libc-(.*)\.so$/', basename(readlink('/lib/libc.so.6')), $matches)) {
+ list($major, $minor) = explode('.', $matches[1]);
+ }
+ }
+
+ if (!($major && $minor)) {
+ return $glibc = '';
+ }
+
+ return $glibc = "glibc{$major}.{$minor}";
+ }
+
+ function getSignature()
+ {
+ if (empty($this->extra)) {
+ return "{$this->sysname}-{$this->release}-{$this->cpu}";
+ }
+ return "{$this->sysname}-{$this->release}-{$this->cpu}-{$this->extra}";
+ }
+
+ function getSysname()
+ {
+ return $this->sysname;
+ }
+
+ function getNodename()
+ {
+ return $this->nodename;
+ }
+
+ function getCpu()
+ {
+ return $this->cpu;
+ }
+
+ function getRelease()
+ {
+ return $this->release;
+ }
+
+ function getExtra()
+ {
+ return $this->extra;
+ }
+
+ function matchSignature($match)
+ {
+ $fragments = is_array($match) ? $match : explode('-', $match);
+ $n = count($fragments);
+ $matches = 0;
+ if ($n > 0) {
+ $matches += $this->_matchFragment($fragments[0], $this->sysname);
+ }
+ if ($n > 1) {
+ $matches += $this->_matchFragment($fragments[1], $this->release);
+ }
+ if ($n > 2) {
+ $matches += $this->_matchFragment($fragments[2], $this->cpu);
+ }
+ if ($n > 3) {
+ $matches += $this->_matchFragment($fragments[3], $this->extra);
+ }
+ return ($matches == $n);
+ }
+
+ function _matchFragment($fragment, $value)
+ {
+ if (strcspn($fragment, '*?') < strlen($fragment)) {
+ $reg = '/^' . str_replace(array('*', '?', '/'), array('.*', '.', '\\/'), $fragment) . '\\z/';
+ return preg_match($reg, $value);
+ }
+ return ($fragment == '*' || !strcasecmp($fragment, $value));
+ }
+
+}
+/*
+ * Local Variables:
+ * indent-tabs-mode: nil
+ * c-basic-offset: 4
+ * End:
+ */
+ PEAR-1.10.1/PEAR/ChannelFile/Parser.php 0000644 0001750 0000144 00000003253 12610427352 016543 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * base xml parser class
+ */
+require_once 'PEAR/XMLParser.php';
+require_once 'PEAR/ChannelFile.php';
+/**
+ * Parser for channel.xml
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_ChannelFile_Parser extends PEAR_XMLParser
+{
+ var $_config;
+ var $_logger;
+ var $_registry;
+
+ function setConfig(&$c)
+ {
+ $this->_config = &$c;
+ $this->_registry = &$c->getRegistry();
+ }
+
+ function setLogger(&$l)
+ {
+ $this->_logger = &$l;
+ }
+
+ function parse($data, $file)
+ {
+ if (PEAR::isError($err = parent::parse($data, $file))) {
+ return $err;
+ }
+
+ $ret = new PEAR_ChannelFile;
+ $ret->setConfig($this->_config);
+ if (isset($this->_logger)) {
+ $ret->setLogger($this->_logger);
+ }
+
+ $ret->fromArray($this->_unserializedData);
+ // make sure the filelist is in the easy to read format needed
+ $ret->flattenFilelist();
+ $ret->setPackagefile($file, $archive);
+ return $ret;
+ }
+} PEAR-1.10.1/PEAR/Command/Auth.xml 0000644 0001750 0000144 00000002314 12610427352 015424 0 ustar cweiske users
+
+ Connects and authenticates to remote server [Deprecated in favor of channel-login]
+ doLogin
+ li
+
+ <channel name>
+WARNING: This function is deprecated in favor of using channel-login
+
+Log in to a remote channel server. If <channel name> is not supplied,
+the default channel is used. To use remote functions in the installer
+that require any kind of privileges, you need to log in first. The
+username and password you enter here will be stored in your per-user
+PEAR configuration (~/.pearrc on Unix-like systems). After logging
+in, your username and password will be sent along in subsequent
+operations on the remote server.
+
+
+ Logs out from the remote server [Deprecated in favor of channel-logout]
+ doLogout
+ lo
+
+
+WARNING: This function is deprecated in favor of using channel-logout
+
+Logs out from the remote server. This command does not actually
+connect to the remote server, it only deletes the stored username and
+password from your user configuration.
+
+ PEAR-1.10.1/PEAR/Command/Auth.php 0000644 0001750 0000144 00000005012 12610427352 015411 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ * @deprecated since 1.8.0alpha1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Channels.php';
+
+/**
+ * PEAR commands for login/logout
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ * @deprecated since 1.8.0alpha1
+ */
+class PEAR_Command_Auth extends PEAR_Command_Channels
+{
+ var $commands = array(
+ 'login' => array(
+ 'summary' => 'Connects and authenticates to remote server [Deprecated in favor of channel-login]',
+ 'shortcut' => 'li',
+ 'function' => 'doLogin',
+ 'options' => array(),
+ 'doc' => '
+WARNING: This function is deprecated in favor of using channel-login
+
+Log in to a remote channel server. If is not supplied,
+the default channel is used. To use remote functions in the installer
+that require any kind of privileges, you need to log in first. The
+username and password you enter here will be stored in your per-user
+PEAR configuration (~/.pearrc on Unix-like systems). After logging
+in, your username and password will be sent along in subsequent
+operations on the remote server.',
+ ),
+ 'logout' => array(
+ 'summary' => 'Logs out from the remote server [Deprecated in favor of channel-logout]',
+ 'shortcut' => 'lo',
+ 'function' => 'doLogout',
+ 'options' => array(),
+ 'doc' => '
+WARNING: This function is deprecated in favor of using channel-logout
+
+Logs out from the remote server. This command does not actually
+connect to the remote server, it only deletes the stored username and
+password from your user configuration.',
+ )
+
+ );
+
+ /**
+ * PEAR_Command_Auth constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Build.xml 0000644 0001750 0000144 00000000404 12610427352 015560 0 ustar cweiske users
+
+ Build an Extension From C Source
+ doBuild
+ b
+
+ [package.xml]
+Builds one or more extensions contained in a package.
+
+ PEAR-1.10.1/PEAR/Command/Build.php 0000644 0001750 0000144 00000004326 12610427352 015556 0 ustar cweiske users
+ * @author Tomas V.V.Cox
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for building extensions.
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Tomas V.V.Cox
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Command_Build extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'build' => array(
+ 'summary' => 'Build an Extension From C Source',
+ 'function' => 'doBuild',
+ 'shortcut' => 'b',
+ 'options' => array(),
+ 'doc' => '[package.xml]
+Builds one or more extensions contained in a package.'
+ ),
+ );
+
+ /**
+ * PEAR_Command_Build constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ function doBuild($command, $options, $params)
+ {
+ require_once 'PEAR/Builder.php';
+ if (sizeof($params) < 1) {
+ $params[0] = 'package.xml';
+ }
+
+ $builder = new PEAR_Builder($this->ui);
+ $this->debug = $this->config->get('verbose');
+ $err = $builder->build($params[0], array(&$this, 'buildCallback'));
+ if (PEAR::isError($err)) {
+ return $err;
+ }
+
+ return true;
+ }
+
+ function buildCallback($what, $data)
+ {
+ if (($what == 'cmdoutput' && $this->debug > 1) ||
+ ($what == 'output' && $this->debug > 0)) {
+ $this->ui->outputData(rtrim($data), 'build');
+ }
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Channels.xml 0000644 0001750 0000144 00000010172 12610427352 016257 0 ustar cweiske users
+
+ List Available Channels
+ doList
+ lc
+
+
+List all available channels for installation.
+
+
+
+ Update the Channel List
+ doUpdateAll
+ uc
+
+
+List all installed packages in all channels.
+
+
+
+ Remove a Channel From the List
+ doDelete
+ cde
+
+ <channel name>
+Delete a channel from the registry. You may not
+remove any channel that has installed packages.
+
+
+
+ Add a Channel
+ doAdd
+ ca
+
+ <channel.xml>
+Add a private channel to the channel list. Note that all
+public channels should be synced using "update-channels".
+Parameter may be either a local file or remote URL to a
+channel.xml.
+
+
+
+ Update an Existing Channel
+ doUpdate
+ cu
+
+
+ f
+ will force download of new channel.xml if an existing channel name is used
+
+
+ c
+ will force download of new channel.xml if an existing channel name is used
+ CHANNEL
+
+
+ [<channel.xml>|<channel name>]
+Update a channel in the channel list directly. Note that all
+public channels can be synced using "update-channels".
+Parameter may be a local or remote channel.xml, or the name of
+an existing channel.
+
+
+
+ Retrieve Information on a Channel
+ doInfo
+ ci
+
+ <package>
+List the files in an installed package.
+
+
+
+ Specify an alias to a channel name
+ doAlias
+ cha
+
+ <channel> <alias>
+Specify a specific alias to use for a channel name.
+The alias may not be an existing channel name or
+alias.
+
+
+
+ Initialize a Channel from its server
+ doDiscover
+ di
+
+ [<channel.xml>|<channel name>]
+Initialize a channel from its server and create a local channel.xml.
+If <channel name> is in the format "<username>:<password>@<channel>" then
+<username> and <password> will be set as the login username/password for
+<channel>. Use caution when passing the username/password in this way, as
+it may allow other users on your computer to briefly view your username/
+password via the system's process list.
+
+
+
+ Connects and authenticates to remote channel server
+ doLogin
+ cli
+
+ <channel name>
+Log in to a remote channel server. If <channel name> is not supplied,
+the default channel is used. To use remote functions in the installer
+that require any kind of privileges, you need to log in first. The
+username and password you enter here will be stored in your per-user
+PEAR configuration (~/.pearrc on Unix-like systems). After logging
+in, your username and password will be sent along in subsequent
+operations on the remote server.
+
+
+ Logs out from the remote channel server
+ doLogout
+ clo
+
+ <channel name>
+Logs out from a remote channel server. If <channel name> is not supplied,
+the default channel is used. This command does not actually connect to the
+remote server, it only deletes the stored username and password from your user
+configuration.
+
+ PEAR-1.10.1/PEAR/Command/Channels.php 0000644 0001750 0000144 00000101244 12610427352 016247 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+define('PEAR_COMMAND_CHANNELS_CHANNEL_EXISTS', -500);
+
+/**
+ * PEAR commands for managing channels.
+ *
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Command_Channels extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'list-channels' => array(
+ 'summary' => 'List Available Channels',
+ 'function' => 'doList',
+ 'shortcut' => 'lc',
+ 'options' => array(),
+ 'doc' => '
+List all available channels for installation.
+',
+ ),
+ 'update-channels' => array(
+ 'summary' => 'Update the Channel List',
+ 'function' => 'doUpdateAll',
+ 'shortcut' => 'uc',
+ 'options' => array(),
+ 'doc' => '
+List all installed packages in all channels.
+'
+ ),
+ 'channel-delete' => array(
+ 'summary' => 'Remove a Channel From the List',
+ 'function' => 'doDelete',
+ 'shortcut' => 'cde',
+ 'options' => array(),
+ 'doc' => '
+Delete a channel from the registry. You may not
+remove any channel that has installed packages.
+'
+ ),
+ 'channel-add' => array(
+ 'summary' => 'Add a Channel',
+ 'function' => 'doAdd',
+ 'shortcut' => 'ca',
+ 'options' => array(),
+ 'doc' => '
+Add a private channel to the channel list. Note that all
+public channels should be synced using "update-channels".
+Parameter may be either a local file or remote URL to a
+channel.xml.
+'
+ ),
+ 'channel-update' => array(
+ 'summary' => 'Update an Existing Channel',
+ 'function' => 'doUpdate',
+ 'shortcut' => 'cu',
+ 'options' => array(
+ 'force' => array(
+ 'shortopt' => 'f',
+ 'doc' => 'will force download of new channel.xml if an existing channel name is used',
+ ),
+ 'channel' => array(
+ 'shortopt' => 'c',
+ 'arg' => 'CHANNEL',
+ 'doc' => 'will force download of new channel.xml if an existing channel name is used',
+ ),
+),
+ 'doc' => '[|]
+Update a channel in the channel list directly. Note that all
+public channels can be synced using "update-channels".
+Parameter may be a local or remote channel.xml, or the name of
+an existing channel.
+'
+ ),
+ 'channel-info' => array(
+ 'summary' => 'Retrieve Information on a Channel',
+ 'function' => 'doInfo',
+ 'shortcut' => 'ci',
+ 'options' => array(),
+ 'doc' => '
+List the files in an installed package.
+'
+ ),
+ 'channel-alias' => array(
+ 'summary' => 'Specify an alias to a channel name',
+ 'function' => 'doAlias',
+ 'shortcut' => 'cha',
+ 'options' => array(),
+ 'doc' => '
+Specify a specific alias to use for a channel name.
+The alias may not be an existing channel name or
+alias.
+'
+ ),
+ 'channel-discover' => array(
+ 'summary' => 'Initialize a Channel from its server',
+ 'function' => 'doDiscover',
+ 'shortcut' => 'di',
+ 'options' => array(),
+ 'doc' => '[|]
+Initialize a channel from its server and create a local channel.xml.
+If is in the format ":@" then
+ and will be set as the login username/password for
+. Use caution when passing the username/password in this way, as
+it may allow other users on your computer to briefly view your username/
+password via the system\'s process list.
+'
+ ),
+ 'channel-login' => array(
+ 'summary' => 'Connects and authenticates to remote channel server',
+ 'shortcut' => 'cli',
+ 'function' => 'doLogin',
+ 'options' => array(),
+ 'doc' => '
+Log in to a remote channel server. If is not supplied,
+the default channel is used. To use remote functions in the installer
+that require any kind of privileges, you need to log in first. The
+username and password you enter here will be stored in your per-user
+PEAR configuration (~/.pearrc on Unix-like systems). After logging
+in, your username and password will be sent along in subsequent
+operations on the remote server.',
+ ),
+ 'channel-logout' => array(
+ 'summary' => 'Logs out from the remote channel server',
+ 'shortcut' => 'clo',
+ 'function' => 'doLogout',
+ 'options' => array(),
+ 'doc' => '
+Logs out from a remote channel server. If is not supplied,
+the default channel is used. This command does not actually connect to the
+remote server, it only deletes the stored username and password from your user
+configuration.',
+ ),
+ );
+
+ /**
+ * PEAR_Command_Registry constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ function _sortChannels($a, $b)
+ {
+ return strnatcasecmp($a->getName(), $b->getName());
+ }
+
+ function doList($command, $options, $params)
+ {
+ $reg = &$this->config->getRegistry();
+ $registered = $reg->getChannels();
+ usort($registered, array(&$this, '_sortchannels'));
+ $i = $j = 0;
+ $data = array(
+ 'caption' => 'Registered Channels:',
+ 'border' => true,
+ 'headline' => array('Channel', 'Alias', 'Summary')
+ );
+ foreach ($registered as $channel) {
+ $data['data'][] = array($channel->getName(),
+ $channel->getAlias(),
+ $channel->getSummary());
+ }
+
+ if (count($registered) === 0) {
+ $data = '(no registered channels)';
+ }
+ $this->ui->outputData($data, $command);
+ return true;
+ }
+
+ function doUpdateAll($command, $options, $params)
+ {
+ $reg = &$this->config->getRegistry();
+ $channels = $reg->getChannels();
+
+ $success = true;
+ foreach ($channels as $channel) {
+ if ($channel->getName() != '__uri') {
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $err = $this->doUpdate('channel-update',
+ $options,
+ array($channel->getName()));
+ if (PEAR::isError($err)) {
+ $this->ui->outputData($err->getMessage(), $command);
+ $success = false;
+ } else {
+ $success &= $err;
+ }
+ }
+ }
+ return $success;
+ }
+
+ function doInfo($command, $options, $params)
+ {
+ if (count($params) !== 1) {
+ return $this->raiseError("No channel specified");
+ }
+
+ $reg = &$this->config->getRegistry();
+ $channel = strtolower($params[0]);
+ if ($reg->channelExists($channel)) {
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($chan)) {
+ return $this->raiseError($chan);
+ }
+ } else {
+ if (strpos($channel, '://')) {
+ $downloader = &$this->getDownloader();
+ $tmpdir = $this->config->get('temp_dir');
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $loc = $downloader->downloadHttp($channel, $this->ui, $tmpdir);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($loc)) {
+ return $this->raiseError('Cannot open "' . $channel .
+ '" (' . $loc->getMessage() . ')');
+ } else {
+ $contents = implode('', file($loc));
+ }
+ } else {
+ if (!file_exists($params[0])) {
+ return $this->raiseError('Unknown channel "' . $channel . '"');
+ }
+
+ $fp = fopen($params[0], 'r');
+ if (!$fp) {
+ return $this->raiseError('Cannot open "' . $params[0] . '"');
+ }
+
+ $contents = '';
+ while (!feof($fp)) {
+ $contents .= fread($fp, 1024);
+ }
+ fclose($fp);
+ }
+
+ if (!class_exists('PEAR_ChannelFile')) {
+ require_once 'PEAR/ChannelFile.php';
+ }
+
+ $chan = new PEAR_ChannelFile;
+ $chan->fromXmlString($contents);
+ $chan->validate();
+ if ($errs = $chan->getErrors(true)) {
+ foreach ($errs as $err) {
+ $this->ui->outputData($err['level'] . ': ' . $err['message']);
+ }
+ return $this->raiseError('Channel file "' . $params[0] . '" is not valid');
+ }
+ }
+
+ if (!$chan) {
+ return $this->raiseError('Serious error: Channel "' . $params[0] .
+ '" has a corrupted registry entry');
+ }
+
+ $channel = $chan->getName();
+ $caption = 'Channel ' . $channel . ' Information:';
+ $data1 = array(
+ 'caption' => $caption,
+ 'border' => true);
+ $data1['data']['server'] = array('Name and Server', $chan->getName());
+ if ($chan->getAlias() != $chan->getName()) {
+ $data1['data']['alias'] = array('Alias', $chan->getAlias());
+ }
+
+ $data1['data']['summary'] = array('Summary', $chan->getSummary());
+ $validate = $chan->getValidationPackage();
+ $data1['data']['vpackage'] = array('Validation Package Name', $validate['_content']);
+ $data1['data']['vpackageversion'] =
+ array('Validation Package Version', $validate['attribs']['version']);
+ $d = array();
+ $d['main'] = $data1;
+
+ $data['data'] = array();
+ $data['caption'] = 'Server Capabilities';
+ $data['headline'] = array('Type', 'Version/REST type', 'Function Name/REST base');
+ if ($chan->supportsREST()) {
+ if ($chan->supportsREST()) {
+ $funcs = $chan->getFunctions('rest');
+ if (!isset($funcs[0])) {
+ $funcs = array($funcs);
+ }
+ foreach ($funcs as $protocol) {
+ $data['data'][] = array('rest', $protocol['attribs']['type'],
+ $protocol['_content']);
+ }
+ }
+ } else {
+ $data['data'][] = array('No supported protocols');
+ }
+
+ $d['protocols'] = $data;
+ $data['data'] = array();
+ $mirrors = $chan->getMirrors();
+ if ($mirrors) {
+ $data['caption'] = 'Channel ' . $channel . ' Mirrors:';
+ unset($data['headline']);
+ foreach ($mirrors as $mirror) {
+ $data['data'][] = array($mirror['attribs']['host']);
+ $d['mirrors'] = $data;
+ }
+
+ foreach ($mirrors as $i => $mirror) {
+ $data['data'] = array();
+ $data['caption'] = 'Mirror ' . $mirror['attribs']['host'] . ' Capabilities';
+ $data['headline'] = array('Type', 'Version/REST type', 'Function Name/REST base');
+ if ($chan->supportsREST($mirror['attribs']['host'])) {
+ if ($chan->supportsREST($mirror['attribs']['host'])) {
+ $funcs = $chan->getFunctions('rest', $mirror['attribs']['host']);
+ if (!isset($funcs[0])) {
+ $funcs = array($funcs);
+ }
+
+ foreach ($funcs as $protocol) {
+ $data['data'][] = array('rest', $protocol['attribs']['type'],
+ $protocol['_content']);
+ }
+ }
+ } else {
+ $data['data'][] = array('No supported protocols');
+ }
+ $d['mirrorprotocols' . $i] = $data;
+ }
+ }
+ $this->ui->outputData($d, 'channel-info');
+ }
+
+ // }}}
+
+ function doDelete($command, $options, $params)
+ {
+ if (count($params) !== 1) {
+ return $this->raiseError('channel-delete: no channel specified');
+ }
+
+ $reg = &$this->config->getRegistry();
+ if (!$reg->channelExists($params[0])) {
+ return $this->raiseError('channel-delete: channel "' . $params[0] . '" does not exist');
+ }
+
+ $channel = $reg->channelName($params[0]);
+ if ($channel == 'pear.php.net') {
+ return $this->raiseError('Cannot delete the pear.php.net channel');
+ }
+
+ if ($channel == 'pecl.php.net') {
+ return $this->raiseError('Cannot delete the pecl.php.net channel');
+ }
+
+ if ($channel == 'doc.php.net') {
+ return $this->raiseError('Cannot delete the doc.php.net channel');
+ }
+
+ if ($channel == '__uri') {
+ return $this->raiseError('Cannot delete the __uri pseudo-channel');
+ }
+
+ if (PEAR::isError($err = $reg->listPackages($channel))) {
+ return $err;
+ }
+
+ if (count($err)) {
+ return $this->raiseError('Channel "' . $channel .
+ '" has installed packages, cannot delete');
+ }
+
+ if (!$reg->deleteChannel($channel)) {
+ return $this->raiseError('Channel "' . $channel . '" deletion failed');
+ } else {
+ $this->config->deleteChannel($channel);
+ $this->ui->outputData('Channel "' . $channel . '" deleted', $command);
+ }
+ }
+
+ function doAdd($command, $options, $params)
+ {
+ if (count($params) !== 1) {
+ return $this->raiseError('channel-add: no channel file specified');
+ }
+
+ if (strpos($params[0], '://')) {
+ $downloader = &$this->getDownloader();
+ $tmpdir = $this->config->get('temp_dir');
+ if (!file_exists($tmpdir)) {
+ require_once 'System.php';
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $err = System::mkdir(array('-p', $tmpdir));
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($err)) {
+ return $this->raiseError('channel-add: temp_dir does not exist: "' .
+ $tmpdir .
+ '" - You can change this location with "pear config-set temp_dir"');
+ }
+ }
+
+ if (!is_writable($tmpdir)) {
+ return $this->raiseError('channel-add: temp_dir is not writable: "' .
+ $tmpdir .
+ '" - You can change this location with "pear config-set temp_dir"');
+ }
+
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $loc = $downloader->downloadHttp($params[0], $this->ui, $tmpdir, null, false);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($loc)) {
+ return $this->raiseError('channel-add: Cannot open "' . $params[0] .
+ '" (' . $loc->getMessage() . ')');
+ }
+
+ list($loc, $lastmodified) = $loc;
+ $contents = implode('', file($loc));
+ } else {
+ $lastmodified = $fp = false;
+ if (file_exists($params[0])) {
+ $fp = fopen($params[0], 'r');
+ }
+
+ if (!$fp) {
+ return $this->raiseError('channel-add: cannot open "' . $params[0] . '"');
+ }
+
+ $contents = '';
+ while (!feof($fp)) {
+ $contents .= fread($fp, 1024);
+ }
+ fclose($fp);
+ }
+
+ if (!class_exists('PEAR_ChannelFile')) {
+ require_once 'PEAR/ChannelFile.php';
+ }
+
+ $channel = new PEAR_ChannelFile;
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $result = $channel->fromXmlString($contents);
+ PEAR::staticPopErrorHandling();
+ if (!$result) {
+ $exit = false;
+ if (count($errors = $channel->getErrors(true))) {
+ foreach ($errors as $error) {
+ $this->ui->outputData(ucfirst($error['level'] . ': ' . $error['message']));
+ if (!$exit) {
+ $exit = $error['level'] == 'error' ? true : false;
+ }
+ }
+ if ($exit) {
+ return $this->raiseError('channel-add: invalid channel.xml file');
+ }
+ }
+ }
+
+ $reg = &$this->config->getRegistry();
+ if ($reg->channelExists($channel->getName())) {
+ return $this->raiseError('channel-add: Channel "' . $channel->getName() .
+ '" exists, use channel-update to update entry', PEAR_COMMAND_CHANNELS_CHANNEL_EXISTS);
+ }
+
+ $ret = $reg->addChannel($channel, $lastmodified);
+ if (PEAR::isError($ret)) {
+ return $ret;
+ }
+
+ if (!$ret) {
+ return $this->raiseError('channel-add: adding Channel "' . $channel->getName() .
+ '" to registry failed');
+ }
+
+ $this->config->setChannels($reg->listChannels());
+ $this->config->writeConfigFile();
+ $this->ui->outputData('Adding Channel "' . $channel->getName() . '" succeeded', $command);
+ }
+
+ function doUpdate($command, $options, $params)
+ {
+ if (count($params) !== 1) {
+ return $this->raiseError("No channel file specified");
+ }
+
+ $tmpdir = $this->config->get('temp_dir');
+ if (!file_exists($tmpdir)) {
+ require_once 'System.php';
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $err = System::mkdir(array('-p', $tmpdir));
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($err)) {
+ return $this->raiseError('channel-add: temp_dir does not exist: "' .
+ $tmpdir .
+ '" - You can change this location with "pear config-set temp_dir"');
+ }
+ }
+
+ if (!is_writable($tmpdir)) {
+ return $this->raiseError('channel-add: temp_dir is not writable: "' .
+ $tmpdir .
+ '" - You can change this location with "pear config-set temp_dir"');
+ }
+
+ $reg = &$this->config->getRegistry();
+ $lastmodified = false;
+ if ((!file_exists($params[0]) || is_dir($params[0]))
+ && $reg->channelExists(strtolower($params[0]))) {
+ $c = $reg->getChannel(strtolower($params[0]));
+ if (PEAR::isError($c)) {
+ return $this->raiseError($c);
+ }
+
+ $this->ui->outputData("Updating channel \"$params[0]\"", $command);
+ $dl = &$this->getDownloader(array());
+ // if force is specified, use a timestamp of "1" to force retrieval
+ $lastmodified = isset($options['force']) ? false : $c->lastModified();
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $contents = $dl->downloadHttp('http://' . $c->getName() . '/channel.xml',
+ $this->ui, $tmpdir, null, $lastmodified);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($contents)) {
+ // Attempt to fall back to https
+ $this->ui->outputData("Channel \"$params[0]\" is not responding over http://, failed with message: " . $contents->getMessage());
+ $this->ui->outputData("Trying channel \"$params[0]\" over https:// instead");
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $contents = $dl->downloadHttp('https://' . $c->getName() . '/channel.xml',
+ $this->ui, $tmpdir, null, $lastmodified);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($contents)) {
+ return $this->raiseError('Cannot retrieve channel.xml for channel "' .
+ $c->getName() . '" (' . $contents->getMessage() . ')');
+ }
+ }
+
+ list($contents, $lastmodified) = $contents;
+ if (!$contents) {
+ $this->ui->outputData("Channel \"$params[0]\" is up to date");
+ return;
+ }
+
+ $contents = implode('', file($contents));
+ if (!class_exists('PEAR_ChannelFile')) {
+ require_once 'PEAR/ChannelFile.php';
+ }
+
+ $channel = new PEAR_ChannelFile;
+ $channel->fromXmlString($contents);
+ if (!$channel->getErrors()) {
+ // security check: is the downloaded file for the channel we got it from?
+ if (strtolower($channel->getName()) != strtolower($c->getName())) {
+ if (!isset($options['force'])) {
+ return $this->raiseError('ERROR: downloaded channel definition file' .
+ ' for channel "' . $channel->getName() . '" from channel "' .
+ strtolower($c->getName()) . '"');
+ }
+
+ $this->ui->log(0, 'WARNING: downloaded channel definition file' .
+ ' for channel "' . $channel->getName() . '" from channel "' .
+ strtolower($c->getName()) . '"');
+ }
+ }
+ } else {
+ if (strpos($params[0], '://')) {
+ $dl = &$this->getDownloader();
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $loc = $dl->downloadHttp($params[0],
+ $this->ui, $tmpdir, null, $lastmodified);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($loc)) {
+ return $this->raiseError("Cannot open " . $params[0] .
+ ' (' . $loc->getMessage() . ')');
+ }
+
+ list($loc, $lastmodified) = $loc;
+ $contents = implode('', file($loc));
+ } else {
+ $fp = false;
+ if (file_exists($params[0])) {
+ $fp = fopen($params[0], 'r');
+ }
+
+ if (!$fp) {
+ return $this->raiseError("Cannot open " . $params[0]);
+ }
+
+ $contents = '';
+ while (!feof($fp)) {
+ $contents .= fread($fp, 1024);
+ }
+ fclose($fp);
+ }
+
+ if (!class_exists('PEAR_ChannelFile')) {
+ require_once 'PEAR/ChannelFile.php';
+ }
+
+ $channel = new PEAR_ChannelFile;
+ $channel->fromXmlString($contents);
+ }
+
+ $exit = false;
+ if (count($errors = $channel->getErrors(true))) {
+ foreach ($errors as $error) {
+ $this->ui->outputData(ucfirst($error['level'] . ': ' . $error['message']));
+ if (!$exit) {
+ $exit = $error['level'] == 'error' ? true : false;
+ }
+ }
+ if ($exit) {
+ return $this->raiseError('Invalid channel.xml file');
+ }
+ }
+
+ if (!$reg->channelExists($channel->getName())) {
+ return $this->raiseError('Error: Channel "' . $channel->getName() .
+ '" does not exist, use channel-add to add an entry');
+ }
+
+ $ret = $reg->updateChannel($channel, $lastmodified);
+ if (PEAR::isError($ret)) {
+ return $ret;
+ }
+
+ if (!$ret) {
+ return $this->raiseError('Updating Channel "' . $channel->getName() .
+ '" in registry failed');
+ }
+
+ $this->config->setChannels($reg->listChannels());
+ $this->config->writeConfigFile();
+ $this->ui->outputData('Update of Channel "' . $channel->getName() . '" succeeded');
+ }
+
+ function &getDownloader()
+ {
+ if (!class_exists('PEAR_Downloader')) {
+ require_once 'PEAR/Downloader.php';
+ }
+ $a = new PEAR_Downloader($this->ui, array(), $this->config);
+ return $a;
+ }
+
+ function doAlias($command, $options, $params)
+ {
+ if (count($params) === 1) {
+ return $this->raiseError('No channel alias specified');
+ }
+
+ if (count($params) !== 2 || (!empty($params[1]) && $params[1]{0} == '-')) {
+ return $this->raiseError(
+ 'Invalid format, correct is: channel-alias channel alias');
+ }
+
+ $reg = &$this->config->getRegistry();
+ if (!$reg->channelExists($params[0], true)) {
+ $extra = '';
+ if ($reg->isAlias($params[0])) {
+ $extra = ' (use "channel-alias ' . $reg->channelName($params[0]) . ' ' .
+ strtolower($params[1]) . '")';
+ }
+
+ return $this->raiseError('"' . $params[0] . '" is not a valid channel' . $extra);
+ }
+
+ if ($reg->isAlias($params[1])) {
+ return $this->raiseError('Channel "' . $reg->channelName($params[1]) . '" is ' .
+ 'already aliased to "' . strtolower($params[1]) . '", cannot re-alias');
+ }
+
+ $chan = $reg->getChannel($params[0]);
+ if (PEAR::isError($chan)) {
+ return $this->raiseError('Corrupt registry? Error retrieving channel "' . $params[0] .
+ '" information (' . $chan->getMessage() . ')');
+ }
+
+ // make it a local alias
+ if (!$chan->setAlias(strtolower($params[1]), true)) {
+ return $this->raiseError('Alias "' . strtolower($params[1]) .
+ '" is not a valid channel alias');
+ }
+
+ $reg->updateChannel($chan);
+ $this->ui->outputData('Channel "' . $chan->getName() . '" aliased successfully to "' .
+ strtolower($params[1]) . '"');
+ }
+
+ /**
+ * The channel-discover command
+ *
+ * @param string $command command name
+ * @param array $options option_name => value
+ * @param array $params list of additional parameters.
+ * $params[0] should contain a string with either:
+ * - or
+ * - :@
+ * @return null|PEAR_Error
+ */
+ function doDiscover($command, $options, $params)
+ {
+ if (count($params) !== 1) {
+ return $this->raiseError("No channel server specified");
+ }
+
+ // Look for the possible input format ":@"
+ if (preg_match('/^(.+):(.+)@(.+)\\z/', $params[0], $matches)) {
+ $username = $matches[1];
+ $password = $matches[2];
+ $channel = $matches[3];
+ } else {
+ $channel = $params[0];
+ }
+
+ $reg = &$this->config->getRegistry();
+ if ($reg->channelExists($channel)) {
+ if (!$reg->isAlias($channel)) {
+ return $this->raiseError("Channel \"$channel\" is already initialized", PEAR_COMMAND_CHANNELS_CHANNEL_EXISTS);
+ }
+
+ return $this->raiseError("A channel alias named \"$channel\" " .
+ 'already exists, aliasing channel "' . $reg->channelName($channel)
+ . '"');
+ }
+
+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
+ $err = $this->doAdd($command, $options, array('http://' . $channel . '/channel.xml'));
+ $this->popErrorHandling();
+ if (PEAR::isError($err)) {
+ if ($err->getCode() === PEAR_COMMAND_CHANNELS_CHANNEL_EXISTS) {
+ return $this->raiseError("Discovery of channel \"$channel\" failed (" .
+ $err->getMessage() . ')');
+ }
+ // Attempt fetch via https
+ $this->ui->outputData("Discovering channel $channel over http:// failed with message: " . $err->getMessage());
+ $this->ui->outputData("Trying to discover channel $channel over https:// instead");
+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
+ $err = $this->doAdd($command, $options, array('https://' . $channel . '/channel.xml'));
+ $this->popErrorHandling();
+ if (PEAR::isError($err)) {
+ return $this->raiseError("Discovery of channel \"$channel\" failed (" .
+ $err->getMessage() . ')');
+ }
+ }
+
+ // Store username/password if they were given
+ // Arguably we should do a logintest on the channel here, but since
+ // that's awkward on a REST-based channel (even "pear login" doesn't
+ // do it for those), and XML-RPC is deprecated, it's fairly pointless.
+ if (isset($username)) {
+ $this->config->set('username', $username, 'user', $channel);
+ $this->config->set('password', $password, 'user', $channel);
+ $this->config->store();
+ $this->ui->outputData("Stored login for channel \"$channel\" using username \"$username\"", $command);
+ }
+
+ $this->ui->outputData("Discovery of channel \"$channel\" succeeded", $command);
+ }
+
+ /**
+ * Execute the 'login' command.
+ *
+ * @param string $command command name
+ * @param array $options option_name => value
+ * @param array $params list of additional parameters
+ *
+ * @return bool TRUE on success or
+ * a PEAR error on failure
+ *
+ * @access public
+ */
+ function doLogin($command, $options, $params)
+ {
+ $reg = &$this->config->getRegistry();
+
+ // If a parameter is supplied, use that as the channel to log in to
+ $channel = isset($params[0]) ? $params[0] : $this->config->get('default_channel');
+
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($chan)) {
+ return $this->raiseError($chan);
+ }
+
+ $server = $this->config->get('preferred_mirror', null, $channel);
+ $username = $this->config->get('username', null, $channel);
+ if (empty($username)) {
+ $username = isset($_ENV['USER']) ? $_ENV['USER'] : null;
+ }
+ $this->ui->outputData("Logging in to $server.", $command);
+
+ list($username, $password) = $this->ui->userDialog(
+ $command,
+ array('Username', 'Password'),
+ array('text', 'password'),
+ array($username, '')
+ );
+ $username = trim($username);
+ $password = trim($password);
+
+ $ourfile = $this->config->getConfFile('user');
+ if (!$ourfile) {
+ $ourfile = $this->config->getConfFile('system');
+ }
+
+ $this->config->set('username', $username, 'user', $channel);
+ $this->config->set('password', $password, 'user', $channel);
+
+ if ($chan->supportsREST()) {
+ $ok = true;
+ }
+
+ if ($ok !== true) {
+ return $this->raiseError('Login failed!');
+ }
+
+ $this->ui->outputData("Logged in.", $command);
+ // avoid changing any temporary settings changed with -d
+ $ourconfig = new PEAR_Config($ourfile, $ourfile);
+ $ourconfig->set('username', $username, 'user', $channel);
+ $ourconfig->set('password', $password, 'user', $channel);
+ $ourconfig->store();
+
+ return true;
+ }
+
+ /**
+ * Execute the 'logout' command.
+ *
+ * @param string $command command name
+ * @param array $options option_name => value
+ * @param array $params list of additional parameters
+ *
+ * @return bool TRUE on success or
+ * a PEAR error on failure
+ *
+ * @access public
+ */
+ function doLogout($command, $options, $params)
+ {
+ $reg = &$this->config->getRegistry();
+
+ // If a parameter is supplied, use that as the channel to log in to
+ $channel = isset($params[0]) ? $params[0] : $this->config->get('default_channel');
+
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($chan)) {
+ return $this->raiseError($chan);
+ }
+
+ $server = $this->config->get('preferred_mirror', null, $channel);
+ $this->ui->outputData("Logging out from $server.", $command);
+ $this->config->remove('username', 'user', $channel);
+ $this->config->remove('password', 'user', $channel);
+ $this->config->store();
+ return true;
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Common.php 0000644 0001750 0000144 00000020035 12610427352 015742 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR.php';
+
+/**
+ * PEAR commands base class
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Command_Common extends PEAR
+{
+ /**
+ * PEAR_Config object used to pass user system and configuration
+ * on when executing commands
+ *
+ * @var PEAR_Config
+ */
+ var $config;
+ /**
+ * @var PEAR_Registry
+ * @access protected
+ */
+ var $_registry;
+
+ /**
+ * User Interface object, for all interaction with the user.
+ * @var object
+ */
+ var $ui;
+
+ var $_deps_rel_trans = array(
+ 'lt' => '<',
+ 'le' => '<=',
+ 'eq' => '=',
+ 'ne' => '!=',
+ 'gt' => '>',
+ 'ge' => '>=',
+ 'has' => '=='
+ );
+
+ var $_deps_type_trans = array(
+ 'pkg' => 'package',
+ 'ext' => 'extension',
+ 'php' => 'PHP',
+ 'prog' => 'external program',
+ 'ldlib' => 'external library for linking',
+ 'rtlib' => 'external runtime library',
+ 'os' => 'operating system',
+ 'websrv' => 'web server',
+ 'sapi' => 'SAPI backend'
+ );
+
+ /**
+ * PEAR_Command_Common constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct();
+ $this->config = &$config;
+ $this->ui = &$ui;
+ }
+
+ /**
+ * Return a list of all the commands defined by this class.
+ * @return array list of commands
+ * @access public
+ */
+ function getCommands()
+ {
+ $ret = array();
+ foreach (array_keys($this->commands) as $command) {
+ $ret[$command] = $this->commands[$command]['summary'];
+ }
+
+ return $ret;
+ }
+
+ /**
+ * Return a list of all the command shortcuts defined by this class.
+ * @return array shortcut => command
+ * @access public
+ */
+ function getShortcuts()
+ {
+ $ret = array();
+ foreach (array_keys($this->commands) as $command) {
+ if (isset($this->commands[$command]['shortcut'])) {
+ $ret[$this->commands[$command]['shortcut']] = $command;
+ }
+ }
+
+ return $ret;
+ }
+
+ function getOptions($command)
+ {
+ $shortcuts = $this->getShortcuts();
+ if (isset($shortcuts[$command])) {
+ $command = $shortcuts[$command];
+ }
+
+ if (isset($this->commands[$command]) &&
+ isset($this->commands[$command]['options'])) {
+ return $this->commands[$command]['options'];
+ }
+
+ return null;
+ }
+
+ function getGetoptArgs($command, &$short_args, &$long_args)
+ {
+ $short_args = '';
+ $long_args = array();
+ if (empty($this->commands[$command]) || empty($this->commands[$command]['options'])) {
+ return;
+ }
+
+ reset($this->commands[$command]['options']);
+ while (list($option, $info) = each($this->commands[$command]['options'])) {
+ $larg = $sarg = '';
+ if (isset($info['arg'])) {
+ if ($info['arg']{0} == '(') {
+ $larg = '==';
+ $sarg = '::';
+ $arg = substr($info['arg'], 1, -1);
+ } else {
+ $larg = '=';
+ $sarg = ':';
+ $arg = $info['arg'];
+ }
+ }
+
+ if (isset($info['shortopt'])) {
+ $short_args .= $info['shortopt'] . $sarg;
+ }
+
+ $long_args[] = $option . $larg;
+ }
+ }
+
+ /**
+ * Returns the help message for the given command
+ *
+ * @param string $command The command
+ * @return mixed A fail string if the command does not have help or
+ * a two elements array containing [0]=>help string,
+ * [1]=> help string for the accepted cmd args
+ */
+ function getHelp($command)
+ {
+ $config = &PEAR_Config::singleton();
+ if (!isset($this->commands[$command])) {
+ return "No such command \"$command\"";
+ }
+
+ $help = null;
+ if (isset($this->commands[$command]['doc'])) {
+ $help = $this->commands[$command]['doc'];
+ }
+
+ if (empty($help)) {
+ // XXX (cox) Fallback to summary if there is no doc (show both?)
+ if (!isset($this->commands[$command]['summary'])) {
+ return "No help for command \"$command\"";
+ }
+ $help = $this->commands[$command]['summary'];
+ }
+
+ if (preg_match_all('/{config\s+([^\}]+)}/e', $help, $matches)) {
+ foreach($matches[0] as $k => $v) {
+ $help = preg_replace("/$v/", $config->get($matches[1][$k]), $help);
+ }
+ }
+
+ return array($help, $this->getHelpArgs($command));
+ }
+
+ /**
+ * Returns the help for the accepted arguments of a command
+ *
+ * @param string $command
+ * @return string The help string
+ */
+ function getHelpArgs($command)
+ {
+ if (isset($this->commands[$command]['options']) &&
+ count($this->commands[$command]['options']))
+ {
+ $help = "Options:\n";
+ foreach ($this->commands[$command]['options'] as $k => $v) {
+ if (isset($v['arg'])) {
+ if ($v['arg'][0] == '(') {
+ $arg = substr($v['arg'], 1, -1);
+ $sapp = " [$arg]";
+ $lapp = "[=$arg]";
+ } else {
+ $sapp = " $v[arg]";
+ $lapp = "=$v[arg]";
+ }
+ } else {
+ $sapp = $lapp = "";
+ }
+
+ if (isset($v['shortopt'])) {
+ $s = $v['shortopt'];
+ $help .= " -$s$sapp, --$k$lapp\n";
+ } else {
+ $help .= " --$k$lapp\n";
+ }
+
+ $p = " ";
+ $doc = rtrim(str_replace("\n", "\n$p", $v['doc']));
+ $help .= " $doc\n";
+ }
+
+ return $help;
+ }
+
+ return null;
+ }
+
+ function run($command, $options, $params)
+ {
+ if (empty($this->commands[$command]['function'])) {
+ // look for shortcuts
+ foreach (array_keys($this->commands) as $cmd) {
+ if (isset($this->commands[$cmd]['shortcut']) && $this->commands[$cmd]['shortcut'] == $command) {
+ if (empty($this->commands[$cmd]['function'])) {
+ return $this->raiseError("unknown command `$command'");
+ } else {
+ $func = $this->commands[$cmd]['function'];
+ }
+ $command = $cmd;
+
+ //$command = $this->commands[$cmd]['function'];
+ break;
+ }
+ }
+ } else {
+ $func = $this->commands[$command]['function'];
+ }
+
+ return $this->$func($command, $options, $params);
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Config.xml 0000644 0001750 0000144 00000006466 12610427352 015744 0 ustar cweiske users
+
+ Show All Settings
+ doConfigShow
+ csh
+
+
+ c
+ show configuration variables for another channel
+ CHAN
+
+
+ [layer]
+Displays all configuration values. An optional argument
+may be used to tell which configuration layer to display. Valid
+configuration layers are "user", "system" and "default". To display
+configurations for different channels, set the default_channel
+configuration variable and run config-show again.
+
+
+
+ Show One Setting
+ doConfigGet
+ cg
+
+
+ c
+ show configuration variables for another channel
+ CHAN
+
+
+ <parameter> [layer]
+Displays the value of one configuration parameter. The
+first argument is the name of the parameter, an optional second argument
+may be used to tell which configuration layer to look in. Valid configuration
+layers are "user", "system" and "default". If no layer is specified, a value
+will be picked from the first layer that defines the parameter, in the order
+just specified. The configuration value will be retrieved for the channel
+specified by the default_channel configuration variable.
+
+
+
+ Change Setting
+ doConfigSet
+ cs
+
+
+ c
+ show configuration variables for another channel
+ CHAN
+
+
+ <parameter> <value> [layer]
+Sets the value of one configuration parameter. The first argument is
+the name of the parameter, the second argument is the new value. Some
+parameters are subject to validation, and the command will fail with
+an error message if the new value does not make sense. An optional
+third argument may be used to specify in which layer to set the
+configuration parameter. The default layer is "user". The
+configuration value will be set for the current channel, which
+is controlled by the default_channel configuration variable.
+
+
+
+ Show Information About Setting
+ doConfigHelp
+ ch
+
+ [parameter]
+Displays help for a configuration parameter. Without arguments it
+displays help for all configuration parameters.
+
+
+
+ Create a Default configuration file
+ doConfigCreate
+ coc
+
+
+ w
+ create a config file for a windows install
+
+
+ <root path> <filename>
+Create a default configuration file with all directory configuration
+variables set to subdirectories of <root path>, and save it as <filename>.
+This is useful especially for creating a configuration file for a remote
+PEAR installation (using the --remoteconfig option of install, upgrade,
+and uninstall).
+
+
+ PEAR-1.10.1/PEAR/Command/Config.php 0000644 0001750 0000144 00000036152 12610427352 015726 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for managing configuration data.
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Command_Config extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'config-show' => array(
+ 'summary' => 'Show All Settings',
+ 'function' => 'doConfigShow',
+ 'shortcut' => 'csh',
+ 'options' => array(
+ 'channel' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'show configuration variables for another channel',
+ 'arg' => 'CHAN',
+ ),
+),
+ 'doc' => '[layer]
+Displays all configuration values. An optional argument
+may be used to tell which configuration layer to display. Valid
+configuration layers are "user", "system" and "default". To display
+configurations for different channels, set the default_channel
+configuration variable and run config-show again.
+',
+ ),
+ 'config-get' => array(
+ 'summary' => 'Show One Setting',
+ 'function' => 'doConfigGet',
+ 'shortcut' => 'cg',
+ 'options' => array(
+ 'channel' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'show configuration variables for another channel',
+ 'arg' => 'CHAN',
+ ),
+),
+ 'doc' => ' [layer]
+Displays the value of one configuration parameter. The
+first argument is the name of the parameter, an optional second argument
+may be used to tell which configuration layer to look in. Valid configuration
+layers are "user", "system" and "default". If no layer is specified, a value
+will be picked from the first layer that defines the parameter, in the order
+just specified. The configuration value will be retrieved for the channel
+specified by the default_channel configuration variable.
+',
+ ),
+ 'config-set' => array(
+ 'summary' => 'Change Setting',
+ 'function' => 'doConfigSet',
+ 'shortcut' => 'cs',
+ 'options' => array(
+ 'channel' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'show configuration variables for another channel',
+ 'arg' => 'CHAN',
+ ),
+),
+ 'doc' => ' [layer]
+Sets the value of one configuration parameter. The first argument is
+the name of the parameter, the second argument is the new value. Some
+parameters are subject to validation, and the command will fail with
+an error message if the new value does not make sense. An optional
+third argument may be used to specify in which layer to set the
+configuration parameter. The default layer is "user". The
+configuration value will be set for the current channel, which
+is controlled by the default_channel configuration variable.
+',
+ ),
+ 'config-help' => array(
+ 'summary' => 'Show Information About Setting',
+ 'function' => 'doConfigHelp',
+ 'shortcut' => 'ch',
+ 'options' => array(),
+ 'doc' => '[parameter]
+Displays help for a configuration parameter. Without arguments it
+displays help for all configuration parameters.
+',
+ ),
+ 'config-create' => array(
+ 'summary' => 'Create a Default configuration file',
+ 'function' => 'doConfigCreate',
+ 'shortcut' => 'coc',
+ 'options' => array(
+ 'windows' => array(
+ 'shortopt' => 'w',
+ 'doc' => 'create a config file for a windows install',
+ ),
+ ),
+ 'doc' => '
+Create a default configuration file with all directory configuration
+variables set to subdirectories of , and save it as .
+This is useful especially for creating a configuration file for a remote
+PEAR installation (using the --remoteconfig option of install, upgrade,
+and uninstall).
+',
+ ),
+ );
+
+ /**
+ * PEAR_Command_Config constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ function doConfigShow($command, $options, $params)
+ {
+ $layer = null;
+ if (is_array($params)) {
+ $layer = isset($params[0]) ? $params[0] : null;
+ }
+
+ // $params[0] -> the layer
+ if ($error = $this->_checkLayer($layer)) {
+ return $this->raiseError("config-show:$error");
+ }
+
+ $keys = $this->config->getKeys();
+ sort($keys);
+ $channel = isset($options['channel']) ? $options['channel'] :
+ $this->config->get('default_channel');
+ $reg = &$this->config->getRegistry();
+ if (!$reg->channelExists($channel)) {
+ return $this->raiseError('Channel "' . $channel . '" does not exist');
+ }
+
+ $channel = $reg->channelName($channel);
+ $data = array('caption' => 'Configuration (channel ' . $channel . '):');
+ foreach ($keys as $key) {
+ $type = $this->config->getType($key);
+ $value = $this->config->get($key, $layer, $channel);
+ if ($type == 'password' && $value) {
+ $value = '********';
+ }
+
+ if ($value === false) {
+ $value = 'false';
+ } elseif ($value === true) {
+ $value = 'true';
+ }
+
+ $data['data'][$this->config->getGroup($key)][] = array($this->config->getPrompt($key) , $key, $value);
+ }
+
+ foreach ($this->config->getLayers() as $layer) {
+ $data['data']['Config Files'][] = array(ucfirst($layer) . ' Configuration File', 'Filename' , $this->config->getConfFile($layer));
+ }
+
+ $this->ui->outputData($data, $command);
+ return true;
+ }
+
+ function doConfigGet($command, $options, $params)
+ {
+ $args_cnt = is_array($params) ? count($params) : 0;
+ switch ($args_cnt) {
+ case 1:
+ $config_key = $params[0];
+ $layer = null;
+ break;
+ case 2:
+ $config_key = $params[0];
+ $layer = $params[1];
+ if ($error = $this->_checkLayer($layer)) {
+ return $this->raiseError("config-get:$error");
+ }
+ break;
+ case 0:
+ default:
+ return $this->raiseError("config-get expects 1 or 2 parameters");
+ }
+
+ $reg = &$this->config->getRegistry();
+ $channel = isset($options['channel']) ? $options['channel'] : $this->config->get('default_channel');
+ if (!$reg->channelExists($channel)) {
+ return $this->raiseError('Channel "' . $channel . '" does not exist');
+ }
+
+ $channel = $reg->channelName($channel);
+ $this->ui->outputData($this->config->get($config_key, $layer, $channel), $command);
+ return true;
+ }
+
+ function doConfigSet($command, $options, $params)
+ {
+ // $param[0] -> a parameter to set
+ // $param[1] -> the value for the parameter
+ // $param[2] -> the layer
+ $failmsg = '';
+ if (count($params) < 2 || count($params) > 3) {
+ $failmsg .= "config-set expects 2 or 3 parameters";
+ return PEAR::raiseError($failmsg);
+ }
+
+ if (isset($params[2]) && ($error = $this->_checkLayer($params[2]))) {
+ $failmsg .= $error;
+ return PEAR::raiseError("config-set:$failmsg");
+ }
+
+ $channel = isset($options['channel']) ? $options['channel'] : $this->config->get('default_channel');
+ $reg = &$this->config->getRegistry();
+ if (!$reg->channelExists($channel)) {
+ return $this->raiseError('Channel "' . $channel . '" does not exist');
+ }
+
+ $channel = $reg->channelName($channel);
+ if ($params[0] == 'default_channel' && !$reg->channelExists($params[1])) {
+ return $this->raiseError('Channel "' . $params[1] . '" does not exist');
+ }
+
+ if ($params[0] == 'preferred_mirror'
+ && (
+ !$reg->mirrorExists($channel, $params[1]) &&
+ (!$reg->channelExists($params[1]) || $channel != $params[1])
+ )
+ ) {
+ $msg = 'Channel Mirror "' . $params[1] . '" does not exist';
+ $msg .= ' in your registry for channel "' . $channel . '".';
+ $msg .= "\n" . 'Attempt to run "pear channel-update ' . $channel .'"';
+ $msg .= ' if you believe this mirror should exist as you may';
+ $msg .= ' have outdated channel information.';
+ return $this->raiseError($msg);
+ }
+
+ if (count($params) == 2) {
+ array_push($params, 'user');
+ $layer = 'user';
+ } else {
+ $layer = $params[2];
+ }
+
+ array_push($params, $channel);
+ if (!call_user_func_array(array(&$this->config, 'set'), $params)) {
+ array_pop($params);
+ $failmsg = "config-set (" . implode(", ", $params) . ") failed, channel $channel";
+ } else {
+ $this->config->store($layer);
+ }
+
+ if ($failmsg) {
+ return $this->raiseError($failmsg);
+ }
+
+ $this->ui->outputData('config-set succeeded', $command);
+ return true;
+ }
+
+ function doConfigHelp($command, $options, $params)
+ {
+ if (empty($params)) {
+ $params = $this->config->getKeys();
+ }
+
+ $data['caption'] = "Config help" . ((count($params) == 1) ? " for $params[0]" : '');
+ $data['headline'] = array('Name', 'Type', 'Description');
+ $data['border'] = true;
+ foreach ($params as $name) {
+ $type = $this->config->getType($name);
+ $docs = $this->config->getDocs($name);
+ if ($type == 'set') {
+ $docs = rtrim($docs) . "\nValid set: " .
+ implode(' ', $this->config->getSetValues($name));
+ }
+
+ $data['data'][] = array($name, $type, $docs);
+ }
+
+ $this->ui->outputData($data, $command);
+ }
+
+ function doConfigCreate($command, $options, $params)
+ {
+ if (count($params) != 2) {
+ return PEAR::raiseError('config-create: must have 2 parameters, root path and ' .
+ 'filename to save as');
+ }
+
+ $root = $params[0];
+ // Clean up the DIRECTORY_SEPARATOR mess
+ $ds2 = DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR;
+ $root = preg_replace(array('!\\\\+!', '!/+!', "!$ds2+!"),
+ array('/', '/', '/'),
+ $root);
+ if ($root{0} != '/') {
+ if (!isset($options['windows'])) {
+ return PEAR::raiseError('Root directory must be an absolute path beginning ' .
+ 'with "/", was: "' . $root . '"');
+ }
+
+ if (!preg_match('/^[A-Za-z]:/', $root)) {
+ return PEAR::raiseError('Root directory must be an absolute path beginning ' .
+ 'with "\\" or "C:\\", was: "' . $root . '"');
+ }
+ }
+
+ $windows = isset($options['windows']);
+ if ($windows) {
+ $root = str_replace('/', '\\', $root);
+ }
+
+ if (!file_exists($params[1]) && !@touch($params[1])) {
+ return PEAR::raiseError('Could not create "' . $params[1] . '"');
+ }
+
+ $params[1] = realpath($params[1]);
+ $config = new PEAR_Config($params[1], '#no#system#config#', false, false);
+ if ($root{strlen($root) - 1} == '/') {
+ $root = substr($root, 0, strlen($root) - 1);
+ }
+
+ $config->noRegistry();
+ $config->set('php_dir', $windows ? "$root\\pear\\php" : "$root/pear/php", 'user');
+ $config->set('data_dir', $windows ? "$root\\pear\\data" : "$root/pear/data");
+ $config->set('www_dir', $windows ? "$root\\pear\\www" : "$root/pear/www");
+ $config->set('cfg_dir', $windows ? "$root\\pear\\cfg" : "$root/pear/cfg");
+ $config->set('ext_dir', $windows ? "$root\\pear\\ext" : "$root/pear/ext");
+ $config->set('doc_dir', $windows ? "$root\\pear\\docs" : "$root/pear/docs");
+ $config->set('test_dir', $windows ? "$root\\pear\\tests" : "$root/pear/tests");
+ $config->set('cache_dir', $windows ? "$root\\pear\\cache" : "$root/pear/cache");
+ $config->set('download_dir', $windows ? "$root\\pear\\download" : "$root/pear/download");
+ $config->set('temp_dir', $windows ? "$root\\pear\\temp" : "$root/pear/temp");
+ $config->set('bin_dir', $windows ? "$root\\pear" : "$root/pear");
+ $config->set('man_dir', $windows ? "$root\\pear\\man" : "$root/pear/man");
+ $config->writeConfigFile();
+ $this->_showConfig($config);
+ $this->ui->outputData('Successfully created default configuration file "' . $params[1] . '"',
+ $command);
+ }
+
+ function _showConfig(&$config)
+ {
+ $params = array('user');
+ $keys = $config->getKeys();
+ sort($keys);
+ $channel = 'pear.php.net';
+ $data = array('caption' => 'Configuration (channel ' . $channel . '):');
+ foreach ($keys as $key) {
+ $type = $config->getType($key);
+ $value = $config->get($key, 'user', $channel);
+ if ($type == 'password' && $value) {
+ $value = '********';
+ }
+
+ if ($value === false) {
+ $value = 'false';
+ } elseif ($value === true) {
+ $value = 'true';
+ }
+ $data['data'][$config->getGroup($key)][] =
+ array($config->getPrompt($key) , $key, $value);
+ }
+
+ foreach ($config->getLayers() as $layer) {
+ $data['data']['Config Files'][] =
+ array(ucfirst($layer) . ' Configuration File', 'Filename' ,
+ $config->getConfFile($layer));
+ }
+
+ $this->ui->outputData($data, 'config-show');
+ return true;
+ }
+
+ /**
+ * Checks if a layer is defined or not
+ *
+ * @param string $layer The layer to search for
+ * @return mixed False on no error or the error message
+ */
+ function _checkLayer($layer = null)
+ {
+ if (!empty($layer) && $layer != 'default') {
+ $layers = $this->config->getLayers();
+ if (!in_array($layer, $layers)) {
+ return " only the layers: \"" . implode('" or "', $layers) . "\" are supported";
+ }
+ }
+
+ return false;
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Install.xml 0000644 0001750 0000144 00000020576 12610427352 016143 0 ustar cweiske users
+
+ Install Package
+ doInstall
+ i
+
+
+ f
+ will overwrite newer installed packages
+
+
+ l
+ do not check for recommended dependency version
+
+
+ n
+ ignore dependencies, install anyway
+
+
+ r
+ do not install files, only register the package as installed
+
+
+ s
+ soft install, fail silently, or upgrade if already installed
+
+
+ B
+ don't build C extensions
+
+
+ Z
+ request uncompressed files when downloading
+
+
+ R
+ root directory used when installing files (ala PHP's INSTALL_ROOT), use packagingroot for RPM
+ DIR
+
+
+ P
+ root directory used when packaging files, like RPM packaging
+ DIR
+
+
+
+ force install even if there were errors
+
+
+ a
+ install all required and optional dependencies
+
+
+ o
+ install all required dependencies
+
+
+ O
+ do not attempt to download any urls or contact channels
+
+
+ p
+ Only list the packages that would be downloaded
+
+
+ [channel/]<package> ...
+Installs one or more PEAR packages. You can specify a package to
+install in four ways:
+
+"Package-1.0.tgz" : installs from a local file
+
+"http://example.com/Package-1.0.tgz" : installs from
+anywhere on the net.
+
+"package.xml" : installs the package described in
+package.xml. Useful for testing, or for wrapping a PEAR package in
+another package manager such as RPM.
+
+"Package[-version/state][.tar]" : queries your default channel's server
+({config master_server}) and downloads the newest package with
+the preferred quality/state ({config preferred_state}).
+
+To retrieve Package version 1.1, use "Package-1.1," to retrieve
+Package state beta, use "Package-beta." To retrieve an uncompressed
+file, append .tar (make sure there is no file by the same name first)
+
+To download a package from another channel, prefix with the channel name like
+"channel/Package"
+
+More than one package may be specified at once. It is ok to mix these
+four ways of specifying packages.
+
+
+
+ Upgrade Package
+ doInstall
+ up
+
+
+ c
+ upgrade packages from a specific channel
+ CHAN
+
+
+ f
+ overwrite newer installed packages
+
+
+ l
+ do not check for recommended dependency version
+
+
+ n
+ ignore dependencies, upgrade anyway
+
+
+ r
+ do not install files, only register the package as upgraded
+
+
+ B
+ don't build C extensions
+
+
+ Z
+ request uncompressed files when downloading
+
+
+ R
+ root directory used when installing files (ala PHP's INSTALL_ROOT)
+ DIR
+
+
+
+ force install even if there were errors
+
+
+ a
+ install all required and optional dependencies
+
+
+ o
+ install all required dependencies
+
+
+ O
+ do not attempt to download any urls or contact channels
+
+
+ p
+ Only list the packages that would be downloaded
+
+
+ <package> ...
+Upgrades one or more PEAR packages. See documentation for the
+"install" command for ways to specify a package.
+
+When upgrading, your package will be updated if the provided new
+package has a higher version number (use the -f option if you need to
+upgrade anyway).
+
+More than one package may be specified at once.
+
+
+
+ Upgrade All Packages [Deprecated in favor of calling upgrade with no parameters]
+ doUpgradeAll
+ ua
+
+
+ c
+ upgrade packages from a specific channel
+ CHAN
+
+
+ n
+ ignore dependencies, upgrade anyway
+
+
+ r
+ do not install files, only register the package as upgraded
+
+
+ B
+ don't build C extensions
+
+
+ Z
+ request uncompressed files when downloading
+
+
+ R
+ root directory used when installing files (ala PHP's INSTALL_ROOT), use packagingroot for RPM
+ DIR
+
+
+
+ force install even if there were errors
+
+
+
+ do not check for recommended dependency version
+
+
+
+WARNING: This function is deprecated in favor of using the upgrade command with no params
+
+Upgrades all packages that have a newer release available. Upgrades are
+done only if there is a release available of the state specified in
+"preferred_state" (currently {config preferred_state}), or a state considered
+more stable.
+
+
+
+ Un-install Package
+ doUninstall
+ un
+
+
+ n
+ ignore dependencies, uninstall anyway
+
+
+ r
+ do not remove files, only register the packages as not installed
+
+
+ R
+ root directory used when installing files (ala PHP's INSTALL_ROOT)
+ DIR
+
+
+
+ force install even if there were errors
+
+
+ O
+ do not attempt to uninstall remotely
+
+
+ [channel/]<package> ...
+Uninstalls one or more PEAR packages. More than one package may be
+specified at once. Prefix with channel name to uninstall from a
+channel not in your default channel ({config default_channel})
+
+
+
+ Unpacks a Pecl Package
+ doBundle
+ bun
+
+
+ d
+ Optional destination directory for unpacking (defaults to current path or "ext" if exists)
+ DIR
+
+
+ f
+ Force the unpacking even if there were errors in the package
+
+
+ <package>
+Unpacks a Pecl Package into the selected location. It will download the
+package if needed.
+
+
+
+ Run Post-Install Scripts bundled with a package
+ doRunScripts
+ rs
+
+ <package>
+Run post-installation scripts in package <package>, if any exist.
+
+
+ PEAR-1.10.1/PEAR/Command/Install.php 0000644 0001750 0000144 00000143146 12610427352 016131 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for installation or deinstallation/upgrading of
+ * packages.
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Command_Install extends PEAR_Command_Common
+{
+ // {{{ properties
+
+ var $commands = array(
+ 'install' => array(
+ 'summary' => 'Install Package',
+ 'function' => 'doInstall',
+ 'shortcut' => 'i',
+ 'options' => array(
+ 'force' => array(
+ 'shortopt' => 'f',
+ 'doc' => 'will overwrite newer installed packages',
+ ),
+ 'loose' => array(
+ 'shortopt' => 'l',
+ 'doc' => 'do not check for recommended dependency version',
+ ),
+ 'nodeps' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'ignore dependencies, install anyway',
+ ),
+ 'register-only' => array(
+ 'shortopt' => 'r',
+ 'doc' => 'do not install files, only register the package as installed',
+ ),
+ 'soft' => array(
+ 'shortopt' => 's',
+ 'doc' => 'soft install, fail silently, or upgrade if already installed',
+ ),
+ 'nobuild' => array(
+ 'shortopt' => 'B',
+ 'doc' => 'don\'t build C extensions',
+ ),
+ 'nocompress' => array(
+ 'shortopt' => 'Z',
+ 'doc' => 'request uncompressed files when downloading',
+ ),
+ 'installroot' => array(
+ 'shortopt' => 'R',
+ 'arg' => 'DIR',
+ 'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',
+ ),
+ 'packagingroot' => array(
+ 'shortopt' => 'P',
+ 'arg' => 'DIR',
+ 'doc' => 'root directory used when packaging files, like RPM packaging',
+ ),
+ 'ignore-errors' => array(
+ 'doc' => 'force install even if there were errors',
+ ),
+ 'alldeps' => array(
+ 'shortopt' => 'a',
+ 'doc' => 'install all required and optional dependencies',
+ ),
+ 'onlyreqdeps' => array(
+ 'shortopt' => 'o',
+ 'doc' => 'install all required dependencies',
+ ),
+ 'offline' => array(
+ 'shortopt' => 'O',
+ 'doc' => 'do not attempt to download any urls or contact channels',
+ ),
+ 'pretend' => array(
+ 'shortopt' => 'p',
+ 'doc' => 'Only list the packages that would be downloaded',
+ ),
+ ),
+ 'doc' => '[channel/] ...
+Installs one or more PEAR packages. You can specify a package to
+install in four ways:
+
+"Package-1.0.tgz" : installs from a local file
+
+"http://example.com/Package-1.0.tgz" : installs from
+anywhere on the net.
+
+"package.xml" : installs the package described in
+package.xml. Useful for testing, or for wrapping a PEAR package in
+another package manager such as RPM.
+
+"Package[-version/state][.tar]" : queries your default channel\'s server
+({config master_server}) and downloads the newest package with
+the preferred quality/state ({config preferred_state}).
+
+To retrieve Package version 1.1, use "Package-1.1," to retrieve
+Package state beta, use "Package-beta." To retrieve an uncompressed
+file, append .tar (make sure there is no file by the same name first)
+
+To download a package from another channel, prefix with the channel name like
+"channel/Package"
+
+More than one package may be specified at once. It is ok to mix these
+four ways of specifying packages.
+'),
+ 'upgrade' => array(
+ 'summary' => 'Upgrade Package',
+ 'function' => 'doInstall',
+ 'shortcut' => 'up',
+ 'options' => array(
+ 'channel' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'upgrade packages from a specific channel',
+ 'arg' => 'CHAN',
+ ),
+ 'force' => array(
+ 'shortopt' => 'f',
+ 'doc' => 'overwrite newer installed packages',
+ ),
+ 'loose' => array(
+ 'shortopt' => 'l',
+ 'doc' => 'do not check for recommended dependency version',
+ ),
+ 'nodeps' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'ignore dependencies, upgrade anyway',
+ ),
+ 'register-only' => array(
+ 'shortopt' => 'r',
+ 'doc' => 'do not install files, only register the package as upgraded',
+ ),
+ 'nobuild' => array(
+ 'shortopt' => 'B',
+ 'doc' => 'don\'t build C extensions',
+ ),
+ 'nocompress' => array(
+ 'shortopt' => 'Z',
+ 'doc' => 'request uncompressed files when downloading',
+ ),
+ 'installroot' => array(
+ 'shortopt' => 'R',
+ 'arg' => 'DIR',
+ 'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',
+ ),
+ 'ignore-errors' => array(
+ 'doc' => 'force install even if there were errors',
+ ),
+ 'alldeps' => array(
+ 'shortopt' => 'a',
+ 'doc' => 'install all required and optional dependencies',
+ ),
+ 'onlyreqdeps' => array(
+ 'shortopt' => 'o',
+ 'doc' => 'install all required dependencies',
+ ),
+ 'offline' => array(
+ 'shortopt' => 'O',
+ 'doc' => 'do not attempt to download any urls or contact channels',
+ ),
+ 'pretend' => array(
+ 'shortopt' => 'p',
+ 'doc' => 'Only list the packages that would be downloaded',
+ ),
+ ),
+ 'doc' => ' ...
+Upgrades one or more PEAR packages. See documentation for the
+"install" command for ways to specify a package.
+
+When upgrading, your package will be updated if the provided new
+package has a higher version number (use the -f option if you need to
+upgrade anyway).
+
+More than one package may be specified at once.
+'),
+ 'upgrade-all' => array(
+ 'summary' => 'Upgrade All Packages [Deprecated in favor of calling upgrade with no parameters]',
+ 'function' => 'doUpgradeAll',
+ 'shortcut' => 'ua',
+ 'options' => array(
+ 'channel' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'upgrade packages from a specific channel',
+ 'arg' => 'CHAN',
+ ),
+ 'nodeps' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'ignore dependencies, upgrade anyway',
+ ),
+ 'register-only' => array(
+ 'shortopt' => 'r',
+ 'doc' => 'do not install files, only register the package as upgraded',
+ ),
+ 'nobuild' => array(
+ 'shortopt' => 'B',
+ 'doc' => 'don\'t build C extensions',
+ ),
+ 'nocompress' => array(
+ 'shortopt' => 'Z',
+ 'doc' => 'request uncompressed files when downloading',
+ ),
+ 'installroot' => array(
+ 'shortopt' => 'R',
+ 'arg' => 'DIR',
+ 'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',
+ ),
+ 'ignore-errors' => array(
+ 'doc' => 'force install even if there were errors',
+ ),
+ 'loose' => array(
+ 'doc' => 'do not check for recommended dependency version',
+ ),
+ ),
+ 'doc' => '
+WARNING: This function is deprecated in favor of using the upgrade command with no params
+
+Upgrades all packages that have a newer release available. Upgrades are
+done only if there is a release available of the state specified in
+"preferred_state" (currently {config preferred_state}), or a state considered
+more stable.
+'),
+ 'uninstall' => array(
+ 'summary' => 'Un-install Package',
+ 'function' => 'doUninstall',
+ 'shortcut' => 'un',
+ 'options' => array(
+ 'nodeps' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'ignore dependencies, uninstall anyway',
+ ),
+ 'register-only' => array(
+ 'shortopt' => 'r',
+ 'doc' => 'do not remove files, only register the packages as not installed',
+ ),
+ 'installroot' => array(
+ 'shortopt' => 'R',
+ 'arg' => 'DIR',
+ 'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',
+ ),
+ 'ignore-errors' => array(
+ 'doc' => 'force install even if there were errors',
+ ),
+ 'offline' => array(
+ 'shortopt' => 'O',
+ 'doc' => 'do not attempt to uninstall remotely',
+ ),
+ ),
+ 'doc' => '[channel/] ...
+Uninstalls one or more PEAR packages. More than one package may be
+specified at once. Prefix with channel name to uninstall from a
+channel not in your default channel ({config default_channel})
+'),
+ 'bundle' => array(
+ 'summary' => 'Unpacks a Pecl Package',
+ 'function' => 'doBundle',
+ 'shortcut' => 'bun',
+ 'options' => array(
+ 'destination' => array(
+ 'shortopt' => 'd',
+ 'arg' => 'DIR',
+ 'doc' => 'Optional destination directory for unpacking (defaults to current path or "ext" if exists)',
+ ),
+ 'force' => array(
+ 'shortopt' => 'f',
+ 'doc' => 'Force the unpacking even if there were errors in the package',
+ ),
+ ),
+ 'doc' => '
+Unpacks a Pecl Package into the selected location. It will download the
+package if needed.
+'),
+ 'run-scripts' => array(
+ 'summary' => 'Run Post-Install Scripts bundled with a package',
+ 'function' => 'doRunScripts',
+ 'shortcut' => 'rs',
+ 'options' => array(
+ ),
+ 'doc' => '
+Run post-installation scripts in package , if any exist.
+'),
+ );
+
+ // }}}
+ // {{{ constructor
+
+ /**
+ * PEAR_Command_Install constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ // }}}
+
+ /**
+ * For unit testing purposes
+ */
+ function &getDownloader(&$ui, $options, &$config)
+ {
+ if (!class_exists('PEAR_Downloader')) {
+ require_once 'PEAR/Downloader.php';
+ }
+ $a = new PEAR_Downloader($ui, $options, $config);
+ return $a;
+ }
+
+ /**
+ * For unit testing purposes
+ */
+ function &getInstaller(&$ui)
+ {
+ if (!class_exists('PEAR_Installer')) {
+ require_once 'PEAR/Installer.php';
+ }
+ $a = new PEAR_Installer($ui);
+ return $a;
+ }
+
+ function enableExtension($binaries, $type)
+ {
+ if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {
+ return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');
+ }
+ $ini = $this->_parseIni($phpini);
+ if (PEAR::isError($ini)) {
+ return $ini;
+ }
+ $line = 0;
+ if ($type == 'extsrc' || $type == 'extbin') {
+ $search = 'extensions';
+ $enable = 'extension';
+ } else {
+ $search = 'zend_extensions';
+ ob_start();
+ phpinfo(INFO_GENERAL);
+ $info = ob_get_contents();
+ ob_end_clean();
+ $debug = function_exists('leak') ? '_debug' : '';
+ $ts = preg_match('/Thread Safety.+enabled/', $info) ? '_ts' : '';
+ $enable = 'zend_extension' . $debug . $ts;
+ }
+ foreach ($ini[$search] as $line => $extension) {
+ if (in_array($extension, $binaries, true) || in_array(
+ $ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {
+ // already enabled - assume if one is, all are
+ return true;
+ }
+ }
+ if ($line) {
+ $newini = array_slice($ini['all'], 0, $line);
+ } else {
+ $newini = array();
+ }
+ foreach ($binaries as $binary) {
+ if ($ini['extension_dir']) {
+ $binary = basename($binary);
+ }
+ $newini[] = $enable . '="' . $binary . '"' . (OS_UNIX ? "\n" : "\r\n");
+ }
+ $newini = array_merge($newini, array_slice($ini['all'], $line));
+ $fp = @fopen($phpini, 'wb');
+ if (!$fp) {
+ return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');
+ }
+ foreach ($newini as $line) {
+ fwrite($fp, $line);
+ }
+ fclose($fp);
+ return true;
+ }
+
+ function disableExtension($binaries, $type)
+ {
+ if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {
+ return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');
+ }
+ $ini = $this->_parseIni($phpini);
+ if (PEAR::isError($ini)) {
+ return $ini;
+ }
+ $line = 0;
+ if ($type == 'extsrc' || $type == 'extbin') {
+ $search = 'extensions';
+ $enable = 'extension';
+ } else {
+ $search = 'zend_extensions';
+ ob_start();
+ phpinfo(INFO_GENERAL);
+ $info = ob_get_contents();
+ ob_end_clean();
+ $debug = function_exists('leak') ? '_debug' : '';
+ $ts = preg_match('/Thread Safety.+enabled/', $info) ? '_ts' : '';
+ $enable = 'zend_extension' . $debug . $ts;
+ }
+ $found = false;
+ foreach ($ini[$search] as $line => $extension) {
+ if (in_array($extension, $binaries, true) || in_array(
+ $ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {
+ $found = true;
+ break;
+ }
+ }
+ if (!$found) {
+ // not enabled
+ return true;
+ }
+ $fp = @fopen($phpini, 'wb');
+ if (!$fp) {
+ return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');
+ }
+ if ($line) {
+ $newini = array_slice($ini['all'], 0, $line);
+ // delete the enable line
+ $newini = array_merge($newini, array_slice($ini['all'], $line + 1));
+ } else {
+ $newini = array_slice($ini['all'], 1);
+ }
+ foreach ($newini as $line) {
+ fwrite($fp, $line);
+ }
+ fclose($fp);
+ return true;
+ }
+
+ function _parseIni($filename)
+ {
+ if (!file_exists($filename)) {
+ return PEAR::raiseError('php.ini "' . $filename . '" does not exist');
+ }
+
+ if (filesize($filename) > 300000) {
+ return PEAR::raiseError('php.ini "' . $filename . '" is too large, aborting');
+ }
+
+ ob_start();
+ phpinfo(INFO_GENERAL);
+ $info = ob_get_contents();
+ ob_end_clean();
+ $debug = function_exists('leak') ? '_debug' : '';
+ $ts = preg_match('/Thread Safety.+enabled/', $info) ? '_ts' : '';
+ $zend_extension_line = 'zend_extension' . $debug . $ts;
+ $all = @file($filename);
+ if ($all === false) {
+ return PEAR::raiseError('php.ini "' . $filename .'" could not be read');
+ }
+ $zend_extensions = $extensions = array();
+ // assume this is right, but pull from the php.ini if it is found
+ $extension_dir = ini_get('extension_dir');
+ foreach ($all as $linenum => $line) {
+ $line = trim($line);
+ if (!$line) {
+ continue;
+ }
+ if ($line[0] == ';') {
+ continue;
+ }
+ if (strtolower(substr($line, 0, 13)) == 'extension_dir') {
+ $line = trim(substr($line, 13));
+ if ($line[0] == '=') {
+ $x = trim(substr($line, 1));
+ $x = explode(';', $x);
+ $extension_dir = str_replace('"', '', array_shift($x));
+ continue;
+ }
+ }
+ if (strtolower(substr($line, 0, 9)) == 'extension') {
+ $line = trim(substr($line, 9));
+ if ($line[0] == '=') {
+ $x = trim(substr($line, 1));
+ $x = explode(';', $x);
+ $extensions[$linenum] = str_replace('"', '', array_shift($x));
+ continue;
+ }
+ }
+ if (strtolower(substr($line, 0, strlen($zend_extension_line))) ==
+ $zend_extension_line) {
+ $line = trim(substr($line, strlen($zend_extension_line)));
+ if ($line[0] == '=') {
+ $x = trim(substr($line, 1));
+ $x = explode(';', $x);
+ $zend_extensions[$linenum] = str_replace('"', '', array_shift($x));
+ continue;
+ }
+ }
+ }
+ return array(
+ 'extensions' => $extensions,
+ 'zend_extensions' => $zend_extensions,
+ 'extension_dir' => $extension_dir,
+ 'all' => $all,
+ );
+ }
+
+ // {{{ doInstall()
+
+ function doInstall($command, $options, $params)
+ {
+ if (!class_exists('PEAR_PackageFile')) {
+ require_once 'PEAR/PackageFile.php';
+ }
+
+ if (isset($options['installroot']) && isset($options['packagingroot'])) {
+ return $this->raiseError('ERROR: cannot use both --installroot and --packagingroot');
+ }
+
+ $reg = &$this->config->getRegistry();
+ $channel = isset($options['channel']) ? $options['channel'] : $this->config->get('default_channel');
+ if (!$reg->channelExists($channel)) {
+ return $this->raiseError('Channel "' . $channel . '" does not exist');
+ }
+
+ if (empty($this->installer)) {
+ $this->installer = &$this->getInstaller($this->ui);
+ }
+
+ if ($command == 'upgrade' || $command == 'upgrade-all') {
+ // If people run the upgrade command but pass nothing, emulate a upgrade-all
+ if ($command == 'upgrade' && empty($params)) {
+ return $this->doUpgradeAll($command, $options, $params);
+ }
+ $options['upgrade'] = true;
+ } else {
+ $packages = $params;
+ }
+
+ $instreg = &$reg; // instreg used to check if package is installed
+ if (isset($options['packagingroot']) && !isset($options['upgrade'])) {
+ $packrootphp_dir = $this->installer->_prependPath(
+ $this->config->get('php_dir', null, 'pear.php.net'),
+ $options['packagingroot']);
+ $metadata_dir = $this->config->get('metadata_dir', null, 'pear.php.net');
+ if ($metadata_dir) {
+ $metadata_dir = $this->installer->_prependPath(
+ $metadata_dir,
+ $options['packagingroot']);
+ }
+ $instreg = new PEAR_Registry($packrootphp_dir, false, false, $metadata_dir); // other instreg!
+
+ if ($this->config->get('verbose') > 2) {
+ $this->ui->outputData('using package root: ' . $options['packagingroot']);
+ }
+ }
+
+ $abstractpackages = $otherpackages = array();
+ // parse params
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+
+ foreach ($params as $param) {
+ if (strpos($param, 'http://') === 0) {
+ $otherpackages[] = $param;
+ continue;
+ }
+
+ if (strpos($param, 'channel://') === false && @file_exists($param)) {
+ if (isset($options['force'])) {
+ $otherpackages[] = $param;
+ continue;
+ }
+
+ $pkg = new PEAR_PackageFile($this->config);
+ $pf = $pkg->fromAnyFile($param, PEAR_VALIDATE_DOWNLOADING);
+ if (PEAR::isError($pf)) {
+ $otherpackages[] = $param;
+ continue;
+ }
+
+ $exists = $reg->packageExists($pf->getPackage(), $pf->getChannel());
+ $pversion = $reg->packageInfo($pf->getPackage(), 'version', $pf->getChannel());
+ $version_compare = version_compare($pf->getVersion(), $pversion, '<=');
+ if ($exists && $version_compare) {
+ if ($this->config->get('verbose')) {
+ $this->ui->outputData('Ignoring installed package ' .
+ $reg->parsedPackageNameToString(
+ array('package' => $pf->getPackage(),
+ 'channel' => $pf->getChannel()), true));
+ }
+ continue;
+ }
+ $otherpackages[] = $param;
+ continue;
+ }
+
+ $e = $reg->parsePackageName($param, $channel);
+ if (PEAR::isError($e)) {
+ $otherpackages[] = $param;
+ } else {
+ $abstractpackages[] = $e;
+ }
+ }
+ PEAR::staticPopErrorHandling();
+
+ // if there are any local package .tgz or remote static url, we can't
+ // filter. The filter only works for abstract packages
+ if (count($abstractpackages) && !isset($options['force'])) {
+ // when not being forced, only do necessary upgrades/installs
+ if (isset($options['upgrade'])) {
+ $abstractpackages = $this->_filterUptodatePackages($abstractpackages, $command);
+ } else {
+ $count = count($abstractpackages);
+ foreach ($abstractpackages as $i => $package) {
+ if (isset($package['group'])) {
+ // do not filter out install groups
+ continue;
+ }
+
+ if ($instreg->packageExists($package['package'], $package['channel'])) {
+ if ($count > 1) {
+ if ($this->config->get('verbose')) {
+ $this->ui->outputData('Ignoring installed package ' .
+ $reg->parsedPackageNameToString($package, true));
+ }
+ unset($abstractpackages[$i]);
+ } elseif ($count === 1) {
+ // Lets try to upgrade it since it's already installed
+ $options['upgrade'] = true;
+ }
+ }
+ }
+ }
+ $abstractpackages =
+ array_map(array($reg, 'parsedPackageNameToString'), $abstractpackages);
+ } elseif (count($abstractpackages)) {
+ $abstractpackages =
+ array_map(array($reg, 'parsedPackageNameToString'), $abstractpackages);
+ }
+
+ $packages = array_merge($abstractpackages, $otherpackages);
+ if (!count($packages)) {
+ $c = '';
+ if (isset($options['channel'])){
+ $c .= ' in channel "' . $options['channel'] . '"';
+ }
+ $this->ui->outputData('Nothing to ' . $command . $c);
+ return true;
+ }
+
+ $this->downloader = &$this->getDownloader($this->ui, $options, $this->config);
+ $errors = $downloaded = $binaries = array();
+ $downloaded = &$this->downloader->download($packages);
+ if (PEAR::isError($downloaded)) {
+ return $this->raiseError($downloaded);
+ }
+
+ $errors = $this->downloader->getErrorMsgs();
+ if (count($errors)) {
+ $err = array();
+ $err['data'] = array();
+ foreach ($errors as $error) {
+ if ($error !== null) {
+ $err['data'][] = array($error);
+ }
+ }
+
+ if (!empty($err['data'])) {
+ $err['headline'] = 'Install Errors';
+ $this->ui->outputData($err);
+ }
+
+ if (!count($downloaded)) {
+ return $this->raiseError("$command failed");
+ }
+ }
+
+ $data = array(
+ 'headline' => 'Packages that would be Installed'
+ );
+
+ if (isset($options['pretend'])) {
+ foreach ($downloaded as $package) {
+ $data['data'][] = array($reg->parsedPackageNameToString($package->getParsedPackage()));
+ }
+ $this->ui->outputData($data, 'pretend');
+ return true;
+ }
+
+ $this->installer->setOptions($options);
+ $this->installer->sortPackagesForInstall($downloaded);
+ if (PEAR::isError($err = $this->installer->setDownloadedPackages($downloaded))) {
+ $this->raiseError($err->getMessage());
+ return true;
+ }
+
+ $binaries = $extrainfo = array();
+ foreach ($downloaded as $param) {
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $info = $this->installer->install($param, $options);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($info)) {
+ $oldinfo = $info;
+ $pkg = &$param->getPackageFile();
+ if ($info->getCode() != PEAR_INSTALLER_NOBINARY) {
+ if (!($info = $pkg->installBinary($this->installer))) {
+ $this->ui->outputData('ERROR: ' .$oldinfo->getMessage());
+ continue;
+ }
+
+ // we just installed a different package than requested,
+ // let's change the param and info so that the rest of this works
+ $param = $info[0];
+ $info = $info[1];
+ }
+ }
+
+ if (!is_array($info)) {
+ return $this->raiseError("$command failed");
+ }
+
+ if ($param->getPackageType() == 'extsrc' ||
+ $param->getPackageType() == 'extbin' ||
+ $param->getPackageType() == 'zendextsrc' ||
+ $param->getPackageType() == 'zendextbin'
+ ) {
+ $pkg = &$param->getPackageFile();
+ if ($instbin = $pkg->getInstalledBinary()) {
+ $instpkg = &$instreg->getPackage($instbin, $pkg->getChannel());
+ } else {
+ $instpkg = &$instreg->getPackage($pkg->getPackage(), $pkg->getChannel());
+ }
+
+ foreach ($instpkg->getFilelist() as $name => $atts) {
+ $pinfo = pathinfo($atts['installed_as']);
+ if (!isset($pinfo['extension']) ||
+ in_array($pinfo['extension'], array('c', 'h'))
+ ) {
+ continue; // make sure we don't match php_blah.h
+ }
+
+ if ((strpos($pinfo['basename'], 'php_') === 0 &&
+ $pinfo['extension'] == 'dll') ||
+ // most unices
+ $pinfo['extension'] == 'so' ||
+ // hp-ux
+ $pinfo['extension'] == 'sl') {
+ $binaries[] = array($atts['installed_as'], $pinfo);
+ break;
+ }
+ }
+
+ if (count($binaries)) {
+ foreach ($binaries as $pinfo) {
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $ret = $this->enableExtension(array($pinfo[0]), $param->getPackageType());
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($ret)) {
+ $extrainfo[] = $ret->getMessage();
+ if ($param->getPackageType() == 'extsrc' ||
+ $param->getPackageType() == 'extbin') {
+ $exttype = 'extension';
+ $extpath = $pinfo[1]['basename'];
+ } else {
+ $exttype = 'zend_extension';
+ $extpath = $atts['installed_as'];
+ }
+ $extrainfo[] = 'You should add "' . $exttype . '=' .
+ $extpath . '" to php.ini';
+ } else {
+ $extrainfo[] = 'Extension ' . $instpkg->getProvidesExtension() .
+ ' enabled in php.ini';
+ }
+ }
+ }
+ }
+
+ if ($this->config->get('verbose') > 0) {
+ $chan = $param->getChannel();
+ $label = $reg->parsedPackageNameToString(
+ array(
+ 'channel' => $chan,
+ 'package' => $param->getPackage(),
+ 'version' => $param->getVersion(),
+ ));
+ $out = array('data' => "$command ok: $label");
+ if (isset($info['release_warnings'])) {
+ $out['release_warnings'] = $info['release_warnings'];
+ }
+ $this->ui->outputData($out, $command);
+
+ if (!isset($options['register-only']) && !isset($options['offline'])) {
+ if ($this->config->isDefinedLayer('ftp')) {
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $info = $this->installer->ftpInstall($param);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($info)) {
+ $this->ui->outputData($info->getMessage());
+ $this->ui->outputData("remote install failed: $label");
+ } else {
+ $this->ui->outputData("remote install ok: $label");
+ }
+ }
+ }
+ }
+
+ $deps = $param->getDeps();
+ if ($deps) {
+ if (isset($deps['group'])) {
+ $groups = $deps['group'];
+ if (!isset($groups[0])) {
+ $groups = array($groups);
+ }
+
+ foreach ($groups as $group) {
+ if ($group['attribs']['name'] == 'default') {
+ // default group is always installed, unless the user
+ // explicitly chooses to install another group
+ continue;
+ }
+ $extrainfo[] = $param->getPackage() . ': Optional feature ' .
+ $group['attribs']['name'] . ' available (' .
+ $group['attribs']['hint'] . ')';
+ }
+
+ $extrainfo[] = $param->getPackage() .
+ ': To install optional features use "pear install ' .
+ $reg->parsedPackageNameToString(
+ array('package' => $param->getPackage(),
+ 'channel' => $param->getChannel()), true) .
+ '#featurename"';
+ }
+ }
+
+ $pkg = &$instreg->getPackage($param->getPackage(), $param->getChannel());
+ // $pkg may be NULL if install is a 'fake' install via --packagingroot
+ if (is_object($pkg)) {
+ $pkg->setConfig($this->config);
+ if ($list = $pkg->listPostinstallScripts()) {
+ $pn = $reg->parsedPackageNameToString(array('channel' =>
+ $param->getChannel(), 'package' => $param->getPackage()), true);
+ $extrainfo[] = $pn . ' has post-install scripts:';
+ foreach ($list as $file) {
+ $extrainfo[] = $file;
+ }
+ $extrainfo[] = $param->getPackage() .
+ ': Use "pear run-scripts ' . $pn . '" to finish setup.';
+ $extrainfo[] = 'DO NOT RUN SCRIPTS FROM UNTRUSTED SOURCES';
+ }
+ }
+ }
+
+ if (count($extrainfo)) {
+ foreach ($extrainfo as $info) {
+ $this->ui->outputData($info);
+ }
+ }
+
+ return true;
+ }
+
+ // }}}
+ // {{{ doUpgradeAll()
+
+ function doUpgradeAll($command, $options, $params)
+ {
+ $reg = &$this->config->getRegistry();
+ $upgrade = array();
+
+ if (isset($options['channel'])) {
+ $channels = array($options['channel']);
+ } else {
+ $channels = $reg->listChannels();
+ }
+
+ foreach ($channels as $channel) {
+ if ($channel == '__uri') {
+ continue;
+ }
+
+ // parse name with channel
+ foreach ($reg->listPackages($channel) as $name) {
+ $upgrade[] = $reg->parsedPackageNameToString(array(
+ 'channel' => $channel,
+ 'package' => $name
+ ));
+ }
+ }
+
+ $err = $this->doInstall($command, $options, $upgrade);
+ if (PEAR::isError($err)) {
+ $this->ui->outputData($err->getMessage(), $command);
+ }
+ }
+
+ // }}}
+ // {{{ doUninstall()
+
+ function doUninstall($command, $options, $params)
+ {
+ if (count($params) < 1) {
+ return $this->raiseError("Please supply the package(s) you want to uninstall");
+ }
+
+ if (empty($this->installer)) {
+ $this->installer = &$this->getInstaller($this->ui);
+ }
+
+ if (isset($options['remoteconfig'])) {
+ $e = $this->config->readFTPConfigFile($options['remoteconfig']);
+ if (!PEAR::isError($e)) {
+ $this->installer->setConfig($this->config);
+ }
+ }
+
+ $reg = &$this->config->getRegistry();
+ $newparams = array();
+ $binaries = array();
+ $badparams = array();
+ foreach ($params as $pkg) {
+ $channel = $this->config->get('default_channel');
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $parsed = $reg->parsePackageName($pkg, $channel);
+ PEAR::staticPopErrorHandling();
+ if (!$parsed || PEAR::isError($parsed)) {
+ $badparams[] = $pkg;
+ continue;
+ }
+ $package = $parsed['package'];
+ $channel = $parsed['channel'];
+ $info = &$reg->getPackage($package, $channel);
+ if ($info === null &&
+ ($channel == 'pear.php.net' || $channel == 'pecl.php.net')) {
+ // make sure this isn't a package that has flipped from pear to pecl but
+ // used a package.xml 1.0
+ $testc = ($channel == 'pear.php.net') ? 'pecl.php.net' : 'pear.php.net';
+ $info = &$reg->getPackage($package, $testc);
+ if ($info !== null) {
+ $channel = $testc;
+ }
+ }
+ if ($info === null) {
+ $badparams[] = $pkg;
+ } else {
+ $newparams[] = &$info;
+ // check for binary packages (this is an alias for those packages if so)
+ if ($installedbinary = $info->getInstalledBinary()) {
+ $this->ui->log('adding binary package ' .
+ $reg->parsedPackageNameToString(array('channel' => $channel,
+ 'package' => $installedbinary), true));
+ $newparams[] = &$reg->getPackage($installedbinary, $channel);
+ }
+ // add the contents of a dependency group to the list of installed packages
+ if (isset($parsed['group'])) {
+ $group = $info->getDependencyGroup($parsed['group']);
+ if ($group) {
+ $installed = $reg->getInstalledGroup($group);
+ if ($installed) {
+ foreach ($installed as $i => $p) {
+ $newparams[] = &$installed[$i];
+ }
+ }
+ }
+ }
+ }
+ }
+ $err = $this->installer->sortPackagesForUninstall($newparams);
+ if (PEAR::isError($err)) {
+ $this->ui->outputData($err->getMessage(), $command);
+ return true;
+ }
+ $params = $newparams;
+ // twist this to use it to check on whether dependent packages are also being uninstalled
+ // for circular dependencies like subpackages
+ $this->installer->setUninstallPackages($newparams);
+ $params = array_merge($params, $badparams);
+ $binaries = array();
+ foreach ($params as $pkg) {
+ $this->installer->pushErrorHandling(PEAR_ERROR_RETURN);
+ if ($err = $this->installer->uninstall($pkg, $options)) {
+ $this->installer->popErrorHandling();
+ if (PEAR::isError($err)) {
+ $this->ui->outputData($err->getMessage(), $command);
+ continue;
+ }
+ if ($pkg->getPackageType() == 'extsrc' ||
+ $pkg->getPackageType() == 'extbin' ||
+ $pkg->getPackageType() == 'zendextsrc' ||
+ $pkg->getPackageType() == 'zendextbin') {
+ if ($instbin = $pkg->getInstalledBinary()) {
+ continue; // this will be uninstalled later
+ }
+
+ foreach ($pkg->getFilelist() as $name => $atts) {
+ $pinfo = pathinfo($atts['installed_as']);
+ if (!isset($pinfo['extension']) ||
+ in_array($pinfo['extension'], array('c', 'h'))) {
+ continue; // make sure we don't match php_blah.h
+ }
+ if ((strpos($pinfo['basename'], 'php_') === 0 &&
+ $pinfo['extension'] == 'dll') ||
+ // most unices
+ $pinfo['extension'] == 'so' ||
+ // hp-ux
+ $pinfo['extension'] == 'sl') {
+ $binaries[] = array($atts['installed_as'], $pinfo);
+ break;
+ }
+ }
+ if (count($binaries)) {
+ foreach ($binaries as $pinfo) {
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $ret = $this->disableExtension(array($pinfo[0]), $pkg->getPackageType());
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($ret)) {
+ $extrainfo[] = $ret->getMessage();
+ if ($pkg->getPackageType() == 'extsrc' ||
+ $pkg->getPackageType() == 'extbin') {
+ $exttype = 'extension';
+ } else {
+ ob_start();
+ phpinfo(INFO_GENERAL);
+ $info = ob_get_contents();
+ ob_end_clean();
+ $debug = function_exists('leak') ? '_debug' : '';
+ $ts = preg_match('/Thread Safety.+enabled/', $info) ? '_ts' : '';
+ $exttype = 'zend_extension' . $debug . $ts;
+ }
+ $this->ui->outputData('Unable to remove "' . $exttype . '=' .
+ $pinfo[1]['basename'] . '" from php.ini', $command);
+ } else {
+ $this->ui->outputData('Extension ' . $pkg->getProvidesExtension() .
+ ' disabled in php.ini', $command);
+ }
+ }
+ }
+ }
+ $savepkg = $pkg;
+ if ($this->config->get('verbose') > 0) {
+ if (is_object($pkg)) {
+ $pkg = $reg->parsedPackageNameToString($pkg);
+ }
+ $this->ui->outputData("uninstall ok: $pkg", $command);
+ }
+ if (!isset($options['offline']) && is_object($savepkg) &&
+ defined('PEAR_REMOTEINSTALL_OK')) {
+ if ($this->config->isDefinedLayer('ftp')) {
+ $this->installer->pushErrorHandling(PEAR_ERROR_RETURN);
+ $info = $this->installer->ftpUninstall($savepkg);
+ $this->installer->popErrorHandling();
+ if (PEAR::isError($info)) {
+ $this->ui->outputData($info->getMessage());
+ $this->ui->outputData("remote uninstall failed: $pkg");
+ } else {
+ $this->ui->outputData("remote uninstall ok: $pkg");
+ }
+ }
+ }
+ } else {
+ $this->installer->popErrorHandling();
+ if (!is_object($pkg)) {
+ return $this->raiseError("uninstall failed: $pkg");
+ }
+ $pkg = $reg->parsedPackageNameToString($pkg);
+ }
+ }
+
+ return true;
+ }
+
+ // }}}
+
+
+ // }}}
+ // {{{ doBundle()
+ /*
+ (cox) It just downloads and untars the package, does not do
+ any check that the PEAR_Installer::_installFile() does.
+ */
+
+ function doBundle($command, $options, $params)
+ {
+ $opts = array(
+ 'force' => true,
+ 'nodeps' => true,
+ 'soft' => true,
+ 'downloadonly' => true
+ );
+ $downloader = &$this->getDownloader($this->ui, $opts, $this->config);
+ $reg = &$this->config->getRegistry();
+ if (count($params) < 1) {
+ return $this->raiseError("Please supply the package you want to bundle");
+ }
+
+ if (isset($options['destination'])) {
+ if (!is_dir($options['destination'])) {
+ System::mkdir('-p ' . $options['destination']);
+ }
+ $dest = realpath($options['destination']);
+ } else {
+ $pwd = getcwd();
+ $dir = $pwd . DIRECTORY_SEPARATOR . 'ext';
+ $dest = is_dir($dir) ? $dir : $pwd;
+ }
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $err = $downloader->setDownloadDir($dest);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($err)) {
+ return PEAR::raiseError('download directory "' . $dest .
+ '" is not writeable.');
+ }
+ $result = &$downloader->download(array($params[0]));
+ if (PEAR::isError($result)) {
+ return $result;
+ }
+ if (!isset($result[0])) {
+ return $this->raiseError('unable to unpack ' . $params[0]);
+ }
+ $pkgfile = &$result[0]->getPackageFile();
+ $pkgname = $pkgfile->getName();
+ $pkgversion = $pkgfile->getVersion();
+
+ // Unpacking -------------------------------------------------
+ $dest .= DIRECTORY_SEPARATOR . $pkgname;
+ $orig = $pkgname . '-' . $pkgversion;
+
+ $tar = new Archive_Tar($pkgfile->getArchiveFile());
+ if (!$tar->extractModify($dest, $orig)) {
+ return $this->raiseError('unable to unpack ' . $pkgfile->getArchiveFile());
+ }
+ $this->ui->outputData("Package ready at '$dest'");
+ // }}}
+ }
+
+ // }}}
+
+ function doRunScripts($command, $options, $params)
+ {
+ if (!isset($params[0])) {
+ return $this->raiseError('run-scripts expects 1 parameter: a package name');
+ }
+
+ $reg = &$this->config->getRegistry();
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $parsed = $reg->parsePackageName($params[0], $this->config->get('default_channel'));
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($parsed)) {
+ return $this->raiseError($parsed);
+ }
+
+ $package = &$reg->getPackage($parsed['package'], $parsed['channel']);
+ if (!is_object($package)) {
+ return $this->raiseError('Could not retrieve package "' . $params[0] . '" from registry');
+ }
+
+ $package->setConfig($this->config);
+ $package->runPostinstallScripts();
+ $this->ui->outputData('Install scripts complete', $command);
+ return true;
+ }
+
+ /**
+ * Given a list of packages, filter out those ones that are already up to date
+ *
+ * @param $packages: packages, in parsed array format !
+ * @return list of packages that can be upgraded
+ */
+ function _filterUptodatePackages($packages, $command)
+ {
+ $reg = &$this->config->getRegistry();
+ $latestReleases = array();
+
+ $ret = array();
+ foreach ($packages as $package) {
+ if (isset($package['group'])) {
+ $ret[] = $package;
+ continue;
+ }
+
+ $channel = $package['channel'];
+ $name = $package['package'];
+ if (!$reg->packageExists($name, $channel)) {
+ $ret[] = $package;
+ continue;
+ }
+
+ if (!isset($latestReleases[$channel])) {
+ // fill in cache for this channel
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($chan)) {
+ return $this->raiseError($chan);
+ }
+
+ $base2 = false;
+ $preferred_mirror = $this->config->get('preferred_mirror', null, $channel);
+ if ($chan->supportsREST($preferred_mirror) &&
+ (
+ //($base2 = $chan->getBaseURL('REST1.4', $preferred_mirror)) ||
+ ($base = $chan->getBaseURL('REST1.0', $preferred_mirror))
+ )
+ ) {
+ $dorest = true;
+ }
+
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ if (!isset($package['state'])) {
+ $state = $this->config->get('preferred_state', null, $channel);
+ } else {
+ $state = $package['state'];
+ }
+
+ if ($dorest) {
+ if ($base2) {
+ $rest = &$this->config->getREST('1.4', array());
+ $base = $base2;
+ } else {
+ $rest = &$this->config->getREST('1.0', array());
+ }
+
+ $installed = array_flip($reg->listPackages($channel));
+ $latest = $rest->listLatestUpgrades($base, $state, $installed, $channel, $reg);
+ }
+
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($latest)) {
+ $this->ui->outputData('Error getting channel info from ' . $channel .
+ ': ' . $latest->getMessage());
+ continue;
+ }
+
+ $latestReleases[$channel] = array_change_key_case($latest);
+ }
+
+ // check package for latest release
+ $name_lower = strtolower($name);
+ if (isset($latestReleases[$channel][$name_lower])) {
+ // if not set, up to date
+ $inst_version = $reg->packageInfo($name, 'version', $channel);
+ $channel_version = $latestReleases[$channel][$name_lower]['version'];
+ if (version_compare($channel_version, $inst_version, 'le')) {
+ // installed version is up-to-date
+ continue;
+ }
+
+ // maintain BC
+ if ($command == 'upgrade-all') {
+ $this->ui->outputData(array('data' => 'Will upgrade ' .
+ $reg->parsedPackageNameToString($package)), $command);
+ }
+ $ret[] = $package;
+ }
+ }
+
+ return $ret;
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Mirror.xml 0000644 0001750 0000144 00000001151 12610427352 015773 0 ustar cweiske users
+
+ Downloads each available package from the default channel
+ doDownloadAll
+ da
+
+
+ c
+ specify a channel other than the default channel
+ CHAN
+
+
+
+Requests a list of available packages from the default channel ({config default_channel})
+and downloads them to current working directory. Note: only
+packages within preferred_state ({config preferred_state}) will be downloaded
+
+ PEAR-1.10.1/PEAR/Command/Mirror.php 0000644 0001750 0000144 00000010635 12610427352 015771 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.2.0
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for providing file mirrors
+ *
+ * @category pear
+ * @package PEAR
+ * @author Alexander Merz
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.2.0
+ */
+class PEAR_Command_Mirror extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'download-all' => array(
+ 'summary' => 'Downloads each available package from the default channel',
+ 'function' => 'doDownloadAll',
+ 'shortcut' => 'da',
+ 'options' => array(
+ 'channel' =>
+ array(
+ 'shortopt' => 'c',
+ 'doc' => 'specify a channel other than the default channel',
+ 'arg' => 'CHAN',
+ ),
+ ),
+ 'doc' => '
+Requests a list of available packages from the default channel ({config default_channel})
+and downloads them to current working directory. Note: only
+packages within preferred_state ({config preferred_state}) will be downloaded'
+ ),
+ );
+
+ /**
+ * PEAR_Command_Mirror constructor.
+ *
+ * @access public
+ * @param object PEAR_Frontend a reference to an frontend
+ * @param object PEAR_Config a reference to the configuration data
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ /**
+ * For unit-testing
+ */
+ function &factory($a)
+ {
+ $a = &PEAR_Command::factory($a, $this->config);
+ return $a;
+ }
+
+ /**
+ * retrieves a list of avaible Packages from master server
+ * and downloads them
+ *
+ * @access public
+ * @param string $command the command
+ * @param array $options the command options before the command
+ * @param array $params the stuff after the command name
+ * @return bool true if successful
+ * @throw PEAR_Error
+ */
+ function doDownloadAll($command, $options, $params)
+ {
+ $savechannel = $this->config->get('default_channel');
+ $reg = &$this->config->getRegistry();
+ $channel = isset($options['channel']) ? $options['channel'] :
+ $this->config->get('default_channel');
+ if (!$reg->channelExists($channel)) {
+ $this->config->set('default_channel', $savechannel);
+ return $this->raiseError('Channel "' . $channel . '" does not exist');
+ }
+ $this->config->set('default_channel', $channel);
+
+ $this->ui->outputData('Using Channel ' . $this->config->get('default_channel'));
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($chan)) {
+ return $this->raiseError($chan);
+ }
+
+ if ($chan->supportsREST($this->config->get('preferred_mirror')) &&
+ $base = $chan->getBaseURL('REST1.0', $this->config->get('preferred_mirror'))) {
+ $rest = &$this->config->getREST('1.0', array());
+ $remoteInfo = array_flip($rest->listPackages($base, $channel));
+ }
+
+ if (PEAR::isError($remoteInfo)) {
+ return $remoteInfo;
+ }
+
+ $cmd = &$this->factory("download");
+ if (PEAR::isError($cmd)) {
+ return $cmd;
+ }
+
+ $this->ui->outputData('Using Preferred State of ' .
+ $this->config->get('preferred_state'));
+ $this->ui->outputData('Gathering release information, please wait...');
+
+ /**
+ * Error handling not necessary, because already done by
+ * the download command
+ */
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $err = $cmd->run('download', array('downloadonly' => true), array_keys($remoteInfo));
+ PEAR::staticPopErrorHandling();
+ $this->config->set('default_channel', $savechannel);
+ if (PEAR::isError($err)) {
+ $this->ui->outputData($err->getMessage());
+ }
+
+ return true;
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Package.xml 0000644 0001750 0000144 00000016066 12610427352 016067 0 ustar cweiske users
+
+ Build Package
+ doPackage
+ p
+
+
+ Z
+ Do not gzip the package file
+
+
+ n
+ Print the name of the packaged file.
+
+
+ [descfile] [descfile2]
+Creates a PEAR package from its description file (usually called
+package.xml). If a second packagefile is passed in, then
+the packager will check to make sure that one is a package.xml
+version 1.0, and the other is a package.xml version 2.0. The
+package.xml version 1.0 will be saved as "package.xml" in the archive,
+and the other as "package2.xml" in the archive"
+
+
+
+ Validate Package Consistency
+ doPackageValidate
+ pv
+
+
+
+
+
+ Run a "cvs diff" for all files in a package
+ doCvsDiff
+ cd
+
+
+ q
+ Be quiet
+
+
+ Q
+ Be really quiet
+
+
+ D
+ Diff against revision of DATE
+ DATE
+
+
+ R
+ Diff against tag for package release REL
+ REL
+
+
+ r
+ Diff against revision REV
+ REV
+
+
+ c
+ Generate context diff
+
+
+ u
+ Generate unified diff
+
+
+ i
+ Ignore case, consider upper- and lower-case letters equivalent
+
+
+ b
+ Ignore changes in amount of white space
+
+
+ B
+ Ignore changes that insert or delete blank lines
+
+
+
+ Report only whether the files differ, no details
+
+
+ n
+ Don't do anything, just pretend
+
+
+ <package.xml>
+Compares all the files in a package. Without any options, this
+command will compare the current code with the last checked-in code.
+Using the -r or -R option you may compare the current code with that
+of a specific release.
+
+
+
+ Set SVN Release Tag
+ doSvnTag
+ sv
+
+
+ q
+ Be quiet
+
+
+ F
+ Move (slide) tag if it exists
+
+
+ d
+ Remove tag
+
+
+ n
+ Don't do anything, just pretend
+
+
+ <package.xml> [files...]
+ Sets a SVN tag on all files in a package. Use this command after you have
+ packaged a distribution tarball with the "package" command to tag what
+ revisions of what files were in that release. If need to fix something
+ after running svntag once, but before the tarball is released to the public,
+ use the "slide" option to move the release tag.
+
+ to include files (such as a second package.xml, or tests not included in the
+ release), pass them as additional parameters.
+
+
+
+ Set CVS Release Tag
+ doCvsTag
+ ct
+
+
+ q
+ Be quiet
+
+
+ Q
+ Be really quiet
+
+
+ F
+ Move (slide) tag if it exists
+
+
+ d
+ Remove tag
+
+
+ n
+ Don't do anything, just pretend
+
+
+ <package.xml> [files...]
+Sets a CVS tag on all files in a package. Use this command after you have
+packaged a distribution tarball with the "package" command to tag what
+revisions of what files were in that release. If need to fix something
+after running cvstag once, but before the tarball is released to the public,
+use the "slide" option to move the release tag.
+
+to include files (such as a second package.xml, or tests not included in the
+release), pass them as additional parameters.
+
+
+
+ Show package dependencies
+ doPackageDependencies
+ pd
+
+ <package-file> or <package.xml> or <install-package-name>
+List all dependencies the package has.
+Can take a tgz / tar file, package.xml or a package name of an installed package.
+
+
+ Sign a package distribution file
+ doSign
+ si
+
+
+ v
+ Display GnuPG output
+
+
+ <package-file>
+Signs a package distribution (.tar or .tgz) file with GnuPG.
+
+
+ Builds an RPM spec file from a PEAR package
+ doMakeRPM
+ rpm
+
+
+ t
+ Use FILE as RPM spec file template
+ FILE
+
+
+ p
+ Use FORMAT as format string for RPM package name, %s is replaced
+by the PEAR package name, defaults to "PEAR::%s".
+ FORMAT
+
+
+ <package-file>
+
+Creates an RPM .spec file for wrapping a PEAR package inside an RPM
+package. Intended to be used from the SPECS directory, with the PEAR
+package tarball in the SOURCES directory:
+
+$ pear makerpm ../SOURCES/Net_Socket-1.0.tgz
+Wrote RPM spec file PEAR::Net_Geo-1.0.spec
+$ rpm -bb PEAR::Net_Socket-1.0.spec
+...
+Wrote: /usr/src/redhat/RPMS/i386/PEAR::Net_Socket-1.0-1.i386.rpm
+
+
+
+ Convert a package.xml 1.0 to package.xml 2.0 format
+ doConvert
+ c2
+
+
+ f
+ do not beautify the filelist.
+
+
+ [descfile] [descfile2]
+Converts a package.xml in 1.0 format into a package.xml
+in 2.0 format. The new file will be named package2.xml by default,
+and package.xml will be used as the old file by default.
+This is not the most intelligent conversion, and should only be
+used for automated conversion or learning the format.
+
+
+ PEAR-1.10.1/PEAR/Command/Package.php 0000644 0001750 0000144 00000116431 12610427352 016053 0 ustar cweiske users
+ * @author Martin Jansen
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for login/logout
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Martin Jansen
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: @package_version@
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+
+class PEAR_Command_Package extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'package' => array(
+ 'summary' => 'Build Package',
+ 'function' => 'doPackage',
+ 'shortcut' => 'p',
+ 'options' => array(
+ 'nocompress' => array(
+ 'shortopt' => 'Z',
+ 'doc' => 'Do not gzip the package file'
+ ),
+ 'showname' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'Print the name of the packaged file.',
+ ),
+ ),
+ 'doc' => '[descfile] [descfile2]
+Creates a PEAR package from its description file (usually called
+package.xml). If a second packagefile is passed in, then
+the packager will check to make sure that one is a package.xml
+version 1.0, and the other is a package.xml version 2.0. The
+package.xml version 1.0 will be saved as "package.xml" in the archive,
+and the other as "package2.xml" in the archive"
+'
+ ),
+ 'package-validate' => array(
+ 'summary' => 'Validate Package Consistency',
+ 'function' => 'doPackageValidate',
+ 'shortcut' => 'pv',
+ 'options' => array(),
+ 'doc' => '
+',
+ ),
+ 'cvsdiff' => array(
+ 'summary' => 'Run a "cvs diff" for all files in a package',
+ 'function' => 'doCvsDiff',
+ 'shortcut' => 'cd',
+ 'options' => array(
+ 'quiet' => array(
+ 'shortopt' => 'q',
+ 'doc' => 'Be quiet',
+ ),
+ 'reallyquiet' => array(
+ 'shortopt' => 'Q',
+ 'doc' => 'Be really quiet',
+ ),
+ 'date' => array(
+ 'shortopt' => 'D',
+ 'doc' => 'Diff against revision of DATE',
+ 'arg' => 'DATE',
+ ),
+ 'release' => array(
+ 'shortopt' => 'R',
+ 'doc' => 'Diff against tag for package release REL',
+ 'arg' => 'REL',
+ ),
+ 'revision' => array(
+ 'shortopt' => 'r',
+ 'doc' => 'Diff against revision REV',
+ 'arg' => 'REV',
+ ),
+ 'context' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'Generate context diff',
+ ),
+ 'unified' => array(
+ 'shortopt' => 'u',
+ 'doc' => 'Generate unified diff',
+ ),
+ 'ignore-case' => array(
+ 'shortopt' => 'i',
+ 'doc' => 'Ignore case, consider upper- and lower-case letters equivalent',
+ ),
+ 'ignore-whitespace' => array(
+ 'shortopt' => 'b',
+ 'doc' => 'Ignore changes in amount of white space',
+ ),
+ 'ignore-blank-lines' => array(
+ 'shortopt' => 'B',
+ 'doc' => 'Ignore changes that insert or delete blank lines',
+ ),
+ 'brief' => array(
+ 'doc' => 'Report only whether the files differ, no details',
+ ),
+ 'dry-run' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'Don\'t do anything, just pretend',
+ ),
+ ),
+ 'doc' => '
+Compares all the files in a package. Without any options, this
+command will compare the current code with the last checked-in code.
+Using the -r or -R option you may compare the current code with that
+of a specific release.
+',
+ ),
+ 'svntag' => array(
+ 'summary' => 'Set SVN Release Tag',
+ 'function' => 'doSvnTag',
+ 'shortcut' => 'sv',
+ 'options' => array(
+ 'quiet' => array(
+ 'shortopt' => 'q',
+ 'doc' => 'Be quiet',
+ ),
+ 'slide' => array(
+ 'shortopt' => 'F',
+ 'doc' => 'Move (slide) tag if it exists',
+ ),
+ 'delete' => array(
+ 'shortopt' => 'd',
+ 'doc' => 'Remove tag',
+ ),
+ 'dry-run' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'Don\'t do anything, just pretend',
+ ),
+ ),
+ 'doc' => ' [files...]
+ Sets a SVN tag on all files in a package. Use this command after you have
+ packaged a distribution tarball with the "package" command to tag what
+ revisions of what files were in that release. If need to fix something
+ after running svntag once, but before the tarball is released to the public,
+ use the "slide" option to move the release tag.
+
+ to include files (such as a second package.xml, or tests not included in the
+ release), pass them as additional parameters.
+ ',
+ ),
+ 'cvstag' => array(
+ 'summary' => 'Set CVS Release Tag',
+ 'function' => 'doCvsTag',
+ 'shortcut' => 'ct',
+ 'options' => array(
+ 'quiet' => array(
+ 'shortopt' => 'q',
+ 'doc' => 'Be quiet',
+ ),
+ 'reallyquiet' => array(
+ 'shortopt' => 'Q',
+ 'doc' => 'Be really quiet',
+ ),
+ 'slide' => array(
+ 'shortopt' => 'F',
+ 'doc' => 'Move (slide) tag if it exists',
+ ),
+ 'delete' => array(
+ 'shortopt' => 'd',
+ 'doc' => 'Remove tag',
+ ),
+ 'dry-run' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'Don\'t do anything, just pretend',
+ ),
+ ),
+ 'doc' => ' [files...]
+Sets a CVS tag on all files in a package. Use this command after you have
+packaged a distribution tarball with the "package" command to tag what
+revisions of what files were in that release. If need to fix something
+after running cvstag once, but before the tarball is released to the public,
+use the "slide" option to move the release tag.
+
+to include files (such as a second package.xml, or tests not included in the
+release), pass them as additional parameters.
+',
+ ),
+ 'package-dependencies' => array(
+ 'summary' => 'Show package dependencies',
+ 'function' => 'doPackageDependencies',
+ 'shortcut' => 'pd',
+ 'options' => array(),
+ 'doc' => ' or or
+List all dependencies the package has.
+Can take a tgz / tar file, package.xml or a package name of an installed package.'
+ ),
+ 'sign' => array(
+ 'summary' => 'Sign a package distribution file',
+ 'function' => 'doSign',
+ 'shortcut' => 'si',
+ 'options' => array(
+ 'verbose' => array(
+ 'shortopt' => 'v',
+ 'doc' => 'Display GnuPG output',
+ ),
+ ),
+ 'doc' => '
+Signs a package distribution (.tar or .tgz) file with GnuPG.',
+ ),
+ 'makerpm' => array(
+ 'summary' => 'Builds an RPM spec file from a PEAR package',
+ 'function' => 'doMakeRPM',
+ 'shortcut' => 'rpm',
+ 'options' => array(
+ 'spec-template' => array(
+ 'shortopt' => 't',
+ 'arg' => 'FILE',
+ 'doc' => 'Use FILE as RPM spec file template'
+ ),
+ 'rpm-pkgname' => array(
+ 'shortopt' => 'p',
+ 'arg' => 'FORMAT',
+ 'doc' => 'Use FORMAT as format string for RPM package name, %s is replaced
+by the PEAR package name, defaults to "PEAR::%s".',
+ ),
+ ),
+ 'doc' => '
+
+Creates an RPM .spec file for wrapping a PEAR package inside an RPM
+package. Intended to be used from the SPECS directory, with the PEAR
+package tarball in the SOURCES directory:
+
+$ pear makerpm ../SOURCES/Net_Socket-1.0.tgz
+Wrote RPM spec file PEAR::Net_Geo-1.0.spec
+$ rpm -bb PEAR::Net_Socket-1.0.spec
+...
+Wrote: /usr/src/redhat/RPMS/i386/PEAR::Net_Socket-1.0-1.i386.rpm
+',
+ ),
+ 'convert' => array(
+ 'summary' => 'Convert a package.xml 1.0 to package.xml 2.0 format',
+ 'function' => 'doConvert',
+ 'shortcut' => 'c2',
+ 'options' => array(
+ 'flat' => array(
+ 'shortopt' => 'f',
+ 'doc' => 'do not beautify the filelist.',
+ ),
+ ),
+ 'doc' => '[descfile] [descfile2]
+Converts a package.xml in 1.0 format into a package.xml
+in 2.0 format. The new file will be named package2.xml by default,
+and package.xml will be used as the old file by default.
+This is not the most intelligent conversion, and should only be
+used for automated conversion or learning the format.
+'
+ ),
+ );
+
+ var $output;
+
+ /**
+ * PEAR_Command_Package constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ function _displayValidationResults($err, $warn, $strict = false)
+ {
+ foreach ($err as $e) {
+ $this->output .= "Error: $e\n";
+ }
+ foreach ($warn as $w) {
+ $this->output .= "Warning: $w\n";
+ }
+ $this->output .= sprintf('Validation: %d error(s), %d warning(s)'."\n",
+ sizeof($err), sizeof($warn));
+ if ($strict && count($err) > 0) {
+ $this->output .= "Fix these errors and try again.";
+ return false;
+ }
+ return true;
+ }
+
+ function &getPackager()
+ {
+ if (!class_exists('PEAR_Packager')) {
+ require_once 'PEAR/Packager.php';
+ }
+ $a = new PEAR_Packager;
+ return $a;
+ }
+
+ function &getPackageFile($config, $debug = false)
+ {
+ if (!class_exists('PEAR_Common')) {
+ require_once 'PEAR/Common.php';
+ }
+ if (!class_exists('PEAR_PackageFile')) {
+ require_once 'PEAR/PackageFile.php';
+ }
+ $a = new PEAR_PackageFile($config, $debug);
+ $common = new PEAR_Common;
+ $common->ui = $this->ui;
+ $a->setLogger($common);
+ return $a;
+ }
+
+ function doPackage($command, $options, $params)
+ {
+ $this->output = '';
+ $pkginfofile = isset($params[0]) ? $params[0] : 'package.xml';
+ $pkg2 = isset($params[1]) ? $params[1] : null;
+ if (!$pkg2 && !isset($params[0]) && file_exists('package2.xml')) {
+ $pkg2 = 'package2.xml';
+ }
+
+ $packager = &$this->getPackager();
+ $compress = empty($options['nocompress']) ? true : false;
+ $result = $packager->package($pkginfofile, $compress, $pkg2);
+ if (PEAR::isError($result)) {
+ return $this->raiseError($result);
+ }
+
+ // Don't want output, only the package file name just created
+ if (isset($options['showname'])) {
+ $this->output = $result;
+ }
+
+ if ($this->output) {
+ $this->ui->outputData($this->output, $command);
+ }
+
+ return true;
+ }
+
+ function doPackageValidate($command, $options, $params)
+ {
+ $this->output = '';
+ if (count($params) < 1) {
+ $params[0] = 'package.xml';
+ }
+
+ $obj = &$this->getPackageFile($this->config, $this->_debug);
+ $obj->rawReturn();
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $info = $obj->fromTgzFile($params[0], PEAR_VALIDATE_NORMAL);
+ if (PEAR::isError($info)) {
+ $info = $obj->fromPackageFile($params[0], PEAR_VALIDATE_NORMAL);
+ } else {
+ $archive = $info->getArchiveFile();
+ $tar = new Archive_Tar($archive);
+ $tar->extract(dirname($info->getPackageFile()));
+ $info->setPackageFile(dirname($info->getPackageFile()) . DIRECTORY_SEPARATOR .
+ $info->getPackage() . '-' . $info->getVersion() . DIRECTORY_SEPARATOR .
+ basename($info->getPackageFile()));
+ }
+
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($info)) {
+ return $this->raiseError($info);
+ }
+
+ $valid = false;
+ if ($info->getPackagexmlVersion() == '2.0') {
+ if ($valid = $info->validate(PEAR_VALIDATE_NORMAL)) {
+ $info->flattenFileList();
+ $valid = $info->validate(PEAR_VALIDATE_PACKAGING);
+ }
+ } else {
+ $valid = $info->validate(PEAR_VALIDATE_PACKAGING);
+ }
+
+ $err = $warn = array();
+ if ($errors = $info->getValidationWarnings()) {
+ foreach ($errors as $error) {
+ if ($error['level'] == 'warning') {
+ $warn[] = $error['message'];
+ } else {
+ $err[] = $error['message'];
+ }
+ }
+ }
+
+ $this->_displayValidationResults($err, $warn);
+ $this->ui->outputData($this->output, $command);
+ return true;
+ }
+
+ function doSvnTag($command, $options, $params)
+ {
+ $this->output = '';
+ $_cmd = $command;
+ if (count($params) < 1) {
+ $help = $this->getHelp($command);
+ return $this->raiseError("$command: missing parameter: $help[0]");
+ }
+
+ $packageFile = realpath($params[0]);
+ $dir = dirname($packageFile);
+ $dir = substr($dir, strrpos($dir, DIRECTORY_SEPARATOR) + 1);
+ $obj = &$this->getPackageFile($this->config, $this->_debug);
+ $info = $obj->fromAnyFile($packageFile, PEAR_VALIDATE_NORMAL);
+ if (PEAR::isError($info)) {
+ return $this->raiseError($info);
+ }
+
+ $err = $warn = array();
+ if (!$info->validate()) {
+ foreach ($info->getValidationWarnings() as $error) {
+ if ($error['level'] == 'warning') {
+ $warn[] = $error['message'];
+ } else {
+ $err[] = $error['message'];
+ }
+ }
+ }
+
+ if (!$this->_displayValidationResults($err, $warn, true)) {
+ $this->ui->outputData($this->output, $command);
+ return $this->raiseError('SVN tag failed');
+ }
+
+ $version = $info->getVersion();
+ $package = $info->getName();
+ $svntag = "$package-$version";
+
+ if (isset($options['delete'])) {
+ return $this->_svnRemoveTag($version, $package, $svntag, $packageFile, $options);
+ }
+
+ $path = $this->_svnFindPath($packageFile);
+
+ // Check if there are any modified files
+ $fp = popen('svn st --xml ' . dirname($packageFile), "r");
+ $out = '';
+ while ($line = fgets($fp, 1024)) {
+ $out .= rtrim($line)."\n";
+ }
+ pclose($fp);
+
+ if (!isset($options['quiet']) && strpos($out, 'item="modified"')) {
+ $params = array(array(
+ 'name' => 'modified',
+ 'type' => 'yesno',
+ 'default' => 'no',
+ 'prompt' => 'You have files in your SVN checkout (' . $path['from'] . ') that have been modified but not committed, do you still want to tag ' . $version . '?',
+ ));
+ $answers = $this->ui->confirmDialog($params);
+
+ if (!in_array($answers['modified'], array('y', 'yes', 'on', '1'))) {
+ return true;
+ }
+ }
+
+ if (isset($options['slide'])) {
+ $this->_svnRemoveTag($version, $package, $svntag, $packageFile, $options);
+ }
+
+ // Check if tag already exists
+ $releaseTag = $path['local']['base'] . 'tags' . DIRECTORY_SEPARATOR . $svntag;
+ $existsCommand = 'svn ls ' . $path['base'] . 'tags/';
+
+ $fp = popen($existsCommand, "r");
+ $out = '';
+ while ($line = fgets($fp, 1024)) {
+ $out .= rtrim($line)."\n";
+ }
+ pclose($fp);
+
+ if (in_array($svntag . DIRECTORY_SEPARATOR, explode("\n", $out))) {
+ $this->ui->outputData($this->output, $command);
+ return $this->raiseError('SVN tag ' . $svntag . ' for ' . $package . ' already exists.');
+ } elseif (file_exists($path['local']['base'] . 'tags') === false) {
+ return $this->raiseError('Can not locate the tags directory at ' . $path['local']['base'] . 'tags');
+ } elseif (is_writeable($path['local']['base'] . 'tags') === false) {
+ return $this->raiseError('Can not write to the tag directory at ' . $path['local']['base'] . 'tags');
+ } else {
+ $makeCommand = 'svn mkdir ' . $releaseTag;
+ $this->output .= "+ $makeCommand\n";
+ if (empty($options['dry-run'])) {
+ // We need to create the tag dir.
+ $fp = popen($makeCommand, "r");
+ $out = '';
+ while ($line = fgets($fp, 1024)) {
+ $out .= rtrim($line)."\n";
+ }
+ pclose($fp);
+ $this->output .= "$out\n";
+ }
+ }
+
+ $command = 'svn';
+ if (isset($options['quiet'])) {
+ $command .= ' -q';
+ }
+
+ $command .= ' copy --parents ';
+
+ $dir = dirname($packageFile);
+ $dir = substr($dir, strrpos($dir, DIRECTORY_SEPARATOR) + 1);
+ $files = array_keys($info->getFilelist());
+ if (!in_array(basename($packageFile), $files)) {
+ $files[] = basename($packageFile);
+ }
+
+ array_shift($params);
+ if (count($params)) {
+ // add in additional files to be tagged (package files and such)
+ $files = array_merge($files, $params);
+ }
+
+ $commands = array();
+ foreach ($files as $file) {
+ if (!file_exists($file)) {
+ $file = $dir . DIRECTORY_SEPARATOR . $file;
+ }
+ $commands[] = $command . ' ' . escapeshellarg($file) . ' ' .
+ escapeshellarg($releaseTag . DIRECTORY_SEPARATOR . $file);
+ }
+
+ $this->output .= implode("\n", $commands) . "\n";
+ if (empty($options['dry-run'])) {
+ foreach ($commands as $command) {
+ $fp = popen($command, "r");
+ while ($line = fgets($fp, 1024)) {
+ $this->output .= rtrim($line)."\n";
+ }
+ pclose($fp);
+ }
+ }
+
+ $command = 'svn ci -m "Tagging the ' . $version . ' release" ' . $releaseTag . "\n";
+ $this->output .= "+ $command\n";
+ if (empty($options['dry-run'])) {
+ $fp = popen($command, "r");
+ while ($line = fgets($fp, 1024)) {
+ $this->output .= rtrim($line)."\n";
+ }
+ pclose($fp);
+ }
+
+ $this->ui->outputData($this->output, $_cmd);
+ return true;
+ }
+
+ function _svnFindPath($file)
+ {
+ $xml = '';
+ $command = "svn info --xml $file";
+ $fp = popen($command, "r");
+ while ($line = fgets($fp, 1024)) {
+ $xml .= rtrim($line)."\n";
+ }
+ pclose($fp);
+ $url_tag = strpos($xml, '');
+ $url = substr($xml, $url_tag + 5, strpos($xml, '', $url_tag + 5) - ($url_tag + 5));
+
+ $path = array();
+ $path['from'] = substr($url, 0, strrpos($url, '/'));
+ $path['base'] = substr($path['from'], 0, strrpos($path['from'], '/') + 1);
+
+ // Figure out the local paths - see http://pear.php.net/bugs/17463
+ $pos = strpos($file, DIRECTORY_SEPARATOR . 'trunk' . DIRECTORY_SEPARATOR);
+ if ($pos === false) {
+ $pos = strpos($file, DIRECTORY_SEPARATOR . 'branches' . DIRECTORY_SEPARATOR);
+ }
+ $path['local']['base'] = substr($file, 0, $pos + 1);
+
+ return $path;
+ }
+
+ function _svnRemoveTag($version, $package, $tag, $packageFile, $options)
+ {
+ $command = 'svn';
+
+ if (isset($options['quiet'])) {
+ $command .= ' -q';
+ }
+
+ $command .= ' remove';
+ $command .= ' -m "Removing tag for the ' . $version . ' release."';
+
+ $path = $this->_svnFindPath($packageFile);
+ $command .= ' ' . $path['base'] . 'tags/' . $tag;
+
+
+ if ($this->config->get('verbose') > 1) {
+ $this->output .= "+ $command\n";
+ }
+
+ $this->output .= "+ $command\n";
+ if (empty($options['dry-run'])) {
+ $fp = popen($command, "r");
+ while ($line = fgets($fp, 1024)) {
+ $this->output .= rtrim($line)."\n";
+ }
+ pclose($fp);
+ }
+
+ $this->ui->outputData($this->output, $command);
+ return true;
+ }
+
+ function doCvsTag($command, $options, $params)
+ {
+ $this->output = '';
+ $_cmd = $command;
+ if (count($params) < 1) {
+ $help = $this->getHelp($command);
+ return $this->raiseError("$command: missing parameter: $help[0]");
+ }
+
+ $packageFile = realpath($params[0]);
+ $obj = &$this->getPackageFile($this->config, $this->_debug);
+ $info = $obj->fromAnyFile($packageFile, PEAR_VALIDATE_NORMAL);
+ if (PEAR::isError($info)) {
+ return $this->raiseError($info);
+ }
+
+ $err = $warn = array();
+ if (!$info->validate()) {
+ foreach ($info->getValidationWarnings() as $error) {
+ if ($error['level'] == 'warning') {
+ $warn[] = $error['message'];
+ } else {
+ $err[] = $error['message'];
+ }
+ }
+ }
+
+ if (!$this->_displayValidationResults($err, $warn, true)) {
+ $this->ui->outputData($this->output, $command);
+ return $this->raiseError('CVS tag failed');
+ }
+
+ $version = $info->getVersion();
+ $cvsversion = preg_replace('/[^a-z0-9]/i', '_', $version);
+ $cvstag = "RELEASE_$cvsversion";
+ $files = array_keys($info->getFilelist());
+ $command = 'cvs';
+ if (isset($options['quiet'])) {
+ $command .= ' -q';
+ }
+
+ if (isset($options['reallyquiet'])) {
+ $command .= ' -Q';
+ }
+
+ $command .= ' tag';
+ if (isset($options['slide'])) {
+ $command .= ' -F';
+ }
+
+ if (isset($options['delete'])) {
+ $command .= ' -d';
+ }
+
+ $command .= ' ' . $cvstag . ' ' . escapeshellarg($params[0]);
+ array_shift($params);
+ if (count($params)) {
+ // add in additional files to be tagged
+ $files = array_merge($files, $params);
+ }
+
+ $dir = dirname($packageFile);
+ $dir = substr($dir, strrpos($dir, '/') + 1);
+ foreach ($files as $file) {
+ if (!file_exists($file)) {
+ $file = $dir . DIRECTORY_SEPARATOR . $file;
+ }
+ $command .= ' ' . escapeshellarg($file);
+ }
+
+ if ($this->config->get('verbose') > 1) {
+ $this->output .= "+ $command\n";
+ }
+
+ $this->output .= "+ $command\n";
+ if (empty($options['dry-run'])) {
+ $fp = popen($command, "r");
+ while ($line = fgets($fp, 1024)) {
+ $this->output .= rtrim($line)."\n";
+ }
+ pclose($fp);
+ }
+
+ $this->ui->outputData($this->output, $_cmd);
+ return true;
+ }
+
+ function doCvsDiff($command, $options, $params)
+ {
+ $this->output = '';
+ if (sizeof($params) < 1) {
+ $help = $this->getHelp($command);
+ return $this->raiseError("$command: missing parameter: $help[0]");
+ }
+
+ $file = realpath($params[0]);
+ $obj = &$this->getPackageFile($this->config, $this->_debug);
+ $info = $obj->fromAnyFile($file, PEAR_VALIDATE_NORMAL);
+ if (PEAR::isError($info)) {
+ return $this->raiseError($info);
+ }
+
+ $err = $warn = array();
+ if (!$info->validate()) {
+ foreach ($info->getValidationWarnings() as $error) {
+ if ($error['level'] == 'warning') {
+ $warn[] = $error['message'];
+ } else {
+ $err[] = $error['message'];
+ }
+ }
+ }
+
+ if (!$this->_displayValidationResults($err, $warn, true)) {
+ $this->ui->outputData($this->output, $command);
+ return $this->raiseError('CVS diff failed');
+ }
+
+ $info1 = $info->getFilelist();
+ $files = $info1;
+ $cmd = "cvs";
+ if (isset($options['quiet'])) {
+ $cmd .= ' -q';
+ unset($options['quiet']);
+ }
+
+ if (isset($options['reallyquiet'])) {
+ $cmd .= ' -Q';
+ unset($options['reallyquiet']);
+ }
+
+ if (isset($options['release'])) {
+ $cvsversion = preg_replace('/[^a-z0-9]/i', '_', $options['release']);
+ $cvstag = "RELEASE_$cvsversion";
+ $options['revision'] = $cvstag;
+ unset($options['release']);
+ }
+
+ $execute = true;
+ if (isset($options['dry-run'])) {
+ $execute = false;
+ unset($options['dry-run']);
+ }
+
+ $cmd .= ' diff';
+ // the rest of the options are passed right on to "cvs diff"
+ foreach ($options as $option => $optarg) {
+ $arg = $short = false;
+ if (isset($this->commands[$command]['options'][$option])) {
+ $arg = $this->commands[$command]['options'][$option]['arg'];
+ $short = $this->commands[$command]['options'][$option]['shortopt'];
+ }
+ $cmd .= $short ? " -$short" : " --$option";
+ if ($arg && $optarg) {
+ $cmd .= ($short ? '' : '=') . escapeshellarg($optarg);
+ }
+ }
+
+ foreach ($files as $file) {
+ $cmd .= ' ' . escapeshellarg($file['name']);
+ }
+
+ if ($this->config->get('verbose') > 1) {
+ $this->output .= "+ $cmd\n";
+ }
+
+ if ($execute) {
+ $fp = popen($cmd, "r");
+ while ($line = fgets($fp, 1024)) {
+ $this->output .= rtrim($line)."\n";
+ }
+ pclose($fp);
+ }
+
+ $this->ui->outputData($this->output, $command);
+ return true;
+ }
+
+ function doPackageDependencies($command, $options, $params)
+ {
+ // $params[0] -> the PEAR package to list its information
+ if (count($params) !== 1) {
+ return $this->raiseError("bad parameter(s), try \"help $command\"");
+ }
+
+ $obj = &$this->getPackageFile($this->config, $this->_debug);
+ if (is_file($params[0]) || strpos($params[0], '.xml') > 0) {
+ $info = $obj->fromAnyFile($params[0], PEAR_VALIDATE_NORMAL);
+ } else {
+ $reg = $this->config->getRegistry();
+ $info = $obj->fromArray($reg->packageInfo($params[0]));
+ }
+
+ if (PEAR::isError($info)) {
+ return $this->raiseError($info);
+ }
+
+ $deps = $info->getDeps();
+ if (is_array($deps)) {
+ if ($info->getPackagexmlVersion() == '1.0') {
+ $data = array(
+ 'caption' => 'Dependencies for pear/' . $info->getPackage(),
+ 'border' => true,
+ 'headline' => array("Required?", "Type", "Name", "Relation", "Version"),
+ );
+
+ foreach ($deps as $d) {
+ if (isset($d['optional'])) {
+ if ($d['optional'] == 'yes') {
+ $req = 'No';
+ } else {
+ $req = 'Yes';
+ }
+ } else {
+ $req = 'Yes';
+ }
+
+ if (isset($this->_deps_rel_trans[$d['rel']])) {
+ $rel = $this->_deps_rel_trans[$d['rel']];
+ } else {
+ $rel = $d['rel'];
+ }
+
+ if (isset($this->_deps_type_trans[$d['type']])) {
+ $type = ucfirst($this->_deps_type_trans[$d['type']]);
+ } else {
+ $type = $d['type'];
+ }
+
+ if (isset($d['name'])) {
+ $name = $d['name'];
+ } else {
+ $name = '';
+ }
+
+ if (isset($d['version'])) {
+ $version = $d['version'];
+ } else {
+ $version = '';
+ }
+
+ $data['data'][] = array($req, $type, $name, $rel, $version);
+ }
+ } else { // package.xml 2.0 dependencies display
+ require_once 'PEAR/Dependency2.php';
+ $deps = $info->getDependencies();
+ $reg = &$this->config->getRegistry();
+ if (is_array($deps)) {
+ $d = new PEAR_Dependency2($this->config, array(), '');
+ $data = array(
+ 'caption' => 'Dependencies for ' . $info->getPackage(),
+ 'border' => true,
+ 'headline' => array("Required?", "Type", "Name", 'Versioning', 'Group'),
+ );
+ foreach ($deps as $type => $subd) {
+ $req = ($type == 'required') ? 'Yes' : 'No';
+ if ($type == 'group' && isset($subd['attribs']['name'])) {
+ $group = $subd['attribs']['name'];
+ } else {
+ $group = '';
+ }
+
+ if (!isset($subd[0])) {
+ $subd = array($subd);
+ }
+
+ foreach ($subd as $groupa) {
+ foreach ($groupa as $deptype => $depinfo) {
+ if ($deptype == 'attribs') {
+ continue;
+ }
+
+ if ($deptype == 'pearinstaller') {
+ $deptype = 'pear Installer';
+ }
+
+ if (!isset($depinfo[0])) {
+ $depinfo = array($depinfo);
+ }
+
+ foreach ($depinfo as $inf) {
+ $name = '';
+ if (isset($inf['channel'])) {
+ $alias = $reg->channelAlias($inf['channel']);
+ if (!$alias) {
+ $alias = '(channel?) ' .$inf['channel'];
+ }
+ $name = $alias . '/';
+
+ }
+ if (isset($inf['name'])) {
+ $name .= $inf['name'];
+ } elseif (isset($inf['pattern'])) {
+ $name .= $inf['pattern'];
+ } else {
+ $name .= '';
+ }
+
+ if (isset($inf['uri'])) {
+ $name .= ' [' . $inf['uri'] . ']';
+ }
+
+ if (isset($inf['conflicts'])) {
+ $ver = 'conflicts';
+ } else {
+ $ver = $d->_getExtraString($inf);
+ }
+
+ $data['data'][] = array($req, ucfirst($deptype), $name,
+ $ver, $group);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ $this->ui->outputData($data, $command);
+ return true;
+ }
+
+ // Fallback
+ $this->ui->outputData("This package does not have any dependencies.", $command);
+ }
+
+ function doSign($command, $options, $params)
+ {
+ // should move most of this code into PEAR_Packager
+ // so it'll be easy to implement "pear package --sign"
+ if (count($params) !== 1) {
+ return $this->raiseError("bad parameter(s), try \"help $command\"");
+ }
+
+ require_once 'System.php';
+ require_once 'Archive/Tar.php';
+
+ if (!file_exists($params[0])) {
+ return $this->raiseError("file does not exist: $params[0]");
+ }
+
+ $obj = $this->getPackageFile($this->config, $this->_debug);
+ $info = $obj->fromTgzFile($params[0], PEAR_VALIDATE_NORMAL);
+ if (PEAR::isError($info)) {
+ return $this->raiseError($info);
+ }
+
+ $tar = new Archive_Tar($params[0]);
+
+ $tmpdir = $this->config->get('temp_dir');
+ $tmpdir = System::mktemp(' -t "' . $tmpdir . '" -d pearsign');
+ if (!$tar->extractList('package2.xml package.xml package.sig', $tmpdir)) {
+ return $this->raiseError("failed to extract tar file");
+ }
+
+ if (file_exists("$tmpdir/package.sig")) {
+ return $this->raiseError("package already signed");
+ }
+
+ $packagexml = 'package.xml';
+ if (file_exists("$tmpdir/package2.xml")) {
+ $packagexml = 'package2.xml';
+ }
+
+ if (file_exists("$tmpdir/package.sig")) {
+ unlink("$tmpdir/package.sig");
+ }
+
+ if (!file_exists("$tmpdir/$packagexml")) {
+ return $this->raiseError("Extracted file $tmpdir/$packagexml not found.");
+ }
+
+ $input = $this->ui->userDialog($command,
+ array('GnuPG Passphrase'),
+ array('password'));
+ if (!isset($input[0])) {
+ //use empty passphrase
+ $input[0] = '';
+ }
+
+ $devnull = (isset($options['verbose'])) ? '' : ' 2>/dev/null';
+ $gpg = popen("gpg --batch --passphrase-fd 0 --armor --detach-sign --output $tmpdir/package.sig $tmpdir/$packagexml" . $devnull, "w");
+ if (!$gpg) {
+ return $this->raiseError("gpg command failed");
+ }
+
+ fwrite($gpg, "$input[0]\n");
+ if (pclose($gpg) || !file_exists("$tmpdir/package.sig")) {
+ return $this->raiseError("gpg sign failed");
+ }
+
+ if (!$tar->addModify("$tmpdir/package.sig", '', $tmpdir)) {
+ return $this->raiseError('failed adding signature to file');
+ }
+
+ $this->ui->outputData("Package signed.", $command);
+ return true;
+ }
+
+ /**
+ * For unit testing purposes
+ */
+ function &getInstaller(&$ui)
+ {
+ if (!class_exists('PEAR_Installer')) {
+ require_once 'PEAR/Installer.php';
+ }
+ $a = new PEAR_Installer($ui);
+ return $a;
+ }
+
+ /**
+ * For unit testing purposes
+ */
+ function &getCommandPackaging(&$ui, &$config)
+ {
+ if (!class_exists('PEAR_Command_Packaging')) {
+ if ($fp = @fopen('PEAR/Command/Packaging.php', 'r', true)) {
+ fclose($fp);
+ include_once 'PEAR/Command/Packaging.php';
+ }
+ }
+
+ if (class_exists('PEAR_Command_Packaging')) {
+ $a = new PEAR_Command_Packaging($ui, $config);
+ } else {
+ $a = null;
+ }
+
+ return $a;
+ }
+
+ function doMakeRPM($command, $options, $params)
+ {
+
+ // Check to see if PEAR_Command_Packaging is installed, and
+ // transparently switch to use the "make-rpm-spec" command from it
+ // instead, if it does. Otherwise, continue to use the old version
+ // of "makerpm" supplied with this package (PEAR).
+ $packaging_cmd = $this->getCommandPackaging($this->ui, $this->config);
+ if ($packaging_cmd !== null) {
+ $this->ui->outputData('PEAR_Command_Packaging is installed; using '.
+ 'newer "make-rpm-spec" command instead');
+ return $packaging_cmd->run('make-rpm-spec', $options, $params);
+ }
+
+ $this->ui->outputData('WARNING: "pear makerpm" is no longer available; an '.
+ 'improved version is available via "pear make-rpm-spec", which '.
+ 'is available by installing PEAR_Command_Packaging');
+ return true;
+ }
+
+ function doConvert($command, $options, $params)
+ {
+ $packagexml = isset($params[0]) ? $params[0] : 'package.xml';
+ $newpackagexml = isset($params[1]) ? $params[1] : dirname($packagexml) .
+ DIRECTORY_SEPARATOR . 'package2.xml';
+ $pkg = &$this->getPackageFile($this->config, $this->_debug);
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $pf = $pkg->fromPackageFile($packagexml, PEAR_VALIDATE_NORMAL);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($pf)) {
+ if (is_array($pf->getUserInfo())) {
+ foreach ($pf->getUserInfo() as $warning) {
+ $this->ui->outputData($warning['message']);
+ }
+ }
+ return $this->raiseError($pf);
+ }
+
+ if (is_a($pf, 'PEAR_PackageFile_v2')) {
+ $this->ui->outputData($packagexml . ' is already a package.xml version 2.0');
+ return true;
+ }
+
+ $gen = &$pf->getDefaultGenerator();
+ $newpf = &$gen->toV2();
+ $newpf->setPackagefile($newpackagexml);
+ $gen = &$newpf->getDefaultGenerator();
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $state = (isset($options['flat']) ? PEAR_VALIDATE_PACKAGING : PEAR_VALIDATE_NORMAL);
+ $saved = $gen->toPackageFile(dirname($newpackagexml), $state, basename($newpackagexml));
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($saved)) {
+ if (is_array($saved->getUserInfo())) {
+ foreach ($saved->getUserInfo() as $warning) {
+ $this->ui->outputData($warning['message']);
+ }
+ }
+
+ $this->ui->outputData($saved->getMessage());
+ return true;
+ }
+
+ $this->ui->outputData('Wrote new version 2.0 package.xml to "' . $saved . '"');
+ return true;
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Pickle.xml 0000644 0001750 0000144 00000002233 12610427352 015732 0 ustar cweiske users
+
+ Build PECL Package
+ doPackage
+ pi
+
+
+ Z
+ Do not gzip the package file
+
+
+ n
+ Print the name of the packaged file.
+
+
+ [descfile]
+Creates a PECL package from its package2.xml file.
+
+An automatic conversion will be made to a package.xml 1.0 and written out to
+disk in the current directory as "package.xml". Note that
+only simple package.xml 2.0 will be converted. package.xml 2.0 with:
+
+ - dependency types other than required/optional PECL package/ext/php/pearinstaller
+ - more than one extsrcrelease or zendextsrcrelease
+ - zendextbinrelease, extbinrelease, phprelease, or bundle release type
+ - dependency groups
+ - ignore tags in release filelist
+ - tasks other than replace
+ - custom roles
+
+will cause pickle to fail, and output an error message. If your package2.xml
+uses any of these features, you are best off using PEAR_PackageFileManager to
+generate both package.xml.
+
+
+ PEAR-1.10.1/PEAR/Command/Pickle.php 0000644 0001750 0000144 00000037026 12610427352 015731 0 ustar cweiske users
+ * @copyright 2005-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for login/logout
+ *
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 2005-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.1
+ */
+
+class PEAR_Command_Pickle extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'pickle' => array(
+ 'summary' => 'Build PECL Package',
+ 'function' => 'doPackage',
+ 'shortcut' => 'pi',
+ 'options' => array(
+ 'nocompress' => array(
+ 'shortopt' => 'Z',
+ 'doc' => 'Do not gzip the package file'
+ ),
+ 'showname' => array(
+ 'shortopt' => 'n',
+ 'doc' => 'Print the name of the packaged file.',
+ ),
+ ),
+ 'doc' => '[descfile]
+Creates a PECL package from its package2.xml file.
+
+An automatic conversion will be made to a package.xml 1.0 and written out to
+disk in the current directory as "package.xml". Note that
+only simple package.xml 2.0 will be converted. package.xml 2.0 with:
+
+ - dependency types other than required/optional PECL package/ext/php/pearinstaller
+ - more than one extsrcrelease or zendextsrcrelease
+ - zendextbinrelease, extbinrelease, phprelease, or bundle release type
+ - dependency groups
+ - ignore tags in release filelist
+ - tasks other than replace
+ - custom roles
+
+will cause pickle to fail, and output an error message. If your package2.xml
+uses any of these features, you are best off using PEAR_PackageFileManager to
+generate both package.xml.
+'
+ ),
+ );
+
+ /**
+ * PEAR_Command_Package constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ /**
+ * For unit-testing ease
+ *
+ * @return PEAR_Packager
+ */
+ function &getPackager()
+ {
+ if (!class_exists('PEAR_Packager')) {
+ require_once 'PEAR/Packager.php';
+ }
+
+ $a = new PEAR_Packager;
+ return $a;
+ }
+
+ /**
+ * For unit-testing ease
+ *
+ * @param PEAR_Config $config
+ * @param bool $debug
+ * @param string|null $tmpdir
+ * @return PEAR_PackageFile
+ */
+ function &getPackageFile($config, $debug = false)
+ {
+ if (!class_exists('PEAR_Common')) {
+ require_once 'PEAR/Common.php';
+ }
+
+ if (!class_exists('PEAR_PackageFile')) {
+ require_once 'PEAR/PackageFile.php';
+ }
+
+ $a = new PEAR_PackageFile($config, $debug);
+ $common = new PEAR_Common;
+ $common->ui = $this->ui;
+ $a->setLogger($common);
+ return $a;
+ }
+
+ function doPackage($command, $options, $params)
+ {
+ $this->output = '';
+ $pkginfofile = isset($params[0]) ? $params[0] : 'package2.xml';
+ $packager = &$this->getPackager();
+ if (PEAR::isError($err = $this->_convertPackage($pkginfofile))) {
+ return $err;
+ }
+
+ $compress = empty($options['nocompress']) ? true : false;
+ $result = $packager->package($pkginfofile, $compress, 'package.xml');
+ if (PEAR::isError($result)) {
+ return $this->raiseError($result);
+ }
+
+ // Don't want output, only the package file name just created
+ if (isset($options['showname'])) {
+ $this->ui->outputData($result, $command);
+ }
+
+ return true;
+ }
+
+ function _convertPackage($packagexml)
+ {
+ $pkg = &$this->getPackageFile($this->config);
+ $pf2 = &$pkg->fromPackageFile($packagexml, PEAR_VALIDATE_NORMAL);
+ if (!is_a($pf2, 'PEAR_PackageFile_v2')) {
+ return $this->raiseError('Cannot process "' .
+ $packagexml . '", is not a package.xml 2.0');
+ }
+
+ require_once 'PEAR/PackageFile/v1.php';
+ $pf = new PEAR_PackageFile_v1;
+ $pf->setConfig($this->config);
+ if ($pf2->getPackageType() != 'extsrc' && $pf2->getPackageType() != 'zendextsrc') {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", is not an extension source package. Using a PEAR_PackageFileManager-based ' .
+ 'script is an option');
+ }
+
+ if (is_array($pf2->getUsesRole())) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", contains custom roles. Using a PEAR_PackageFileManager-based script or ' .
+ 'the convert command is an option');
+ }
+
+ if (is_array($pf2->getUsesTask())) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", contains custom tasks. Using a PEAR_PackageFileManager-based script or ' .
+ 'the convert command is an option');
+ }
+
+ $deps = $pf2->getDependencies();
+ if (isset($deps['group'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", contains dependency groups. Using a PEAR_PackageFileManager-based script ' .
+ 'or the convert command is an option');
+ }
+
+ if (isset($deps['required']['subpackage']) ||
+ isset($deps['optional']['subpackage'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", contains subpackage dependencies. Using a PEAR_PackageFileManager-based '.
+ 'script is an option');
+ }
+
+ if (isset($deps['required']['os'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", contains os dependencies. Using a PEAR_PackageFileManager-based '.
+ 'script is an option');
+ }
+
+ if (isset($deps['required']['arch'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", contains arch dependencies. Using a PEAR_PackageFileManager-based '.
+ 'script is an option');
+ }
+
+ $pf->setPackage($pf2->getPackage());
+ $pf->setSummary($pf2->getSummary());
+ $pf->setDescription($pf2->getDescription());
+ foreach ($pf2->getMaintainers() as $maintainer) {
+ $pf->addMaintainer($maintainer['role'], $maintainer['handle'],
+ $maintainer['name'], $maintainer['email']);
+ }
+
+ $pf->setVersion($pf2->getVersion());
+ $pf->setDate($pf2->getDate());
+ $pf->setLicense($pf2->getLicense());
+ $pf->setState($pf2->getState());
+ $pf->setNotes($pf2->getNotes());
+ $pf->addPhpDep($deps['required']['php']['min'], 'ge');
+ if (isset($deps['required']['php']['max'])) {
+ $pf->addPhpDep($deps['required']['php']['max'], 'le');
+ }
+
+ if (isset($deps['required']['package'])) {
+ if (!isset($deps['required']['package'][0])) {
+ $deps['required']['package'] = array($deps['required']['package']);
+ }
+
+ foreach ($deps['required']['package'] as $dep) {
+ if (!isset($dep['channel'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml . '"' .
+ ' contains uri-based dependency on a package. Using a ' .
+ 'PEAR_PackageFileManager-based script is an option');
+ }
+
+ if ($dep['channel'] != 'pear.php.net'
+ && $dep['channel'] != 'pecl.php.net'
+ && $dep['channel'] != 'doc.php.net') {
+ return $this->raiseError('Cannot safely convert "' . $packagexml . '"' .
+ ' contains dependency on a non-standard channel package. Using a ' .
+ 'PEAR_PackageFileManager-based script is an option');
+ }
+
+ if (isset($dep['conflicts'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml . '"' .
+ ' contains conflicts dependency. Using a ' .
+ 'PEAR_PackageFileManager-based script is an option');
+ }
+
+ if (isset($dep['exclude'])) {
+ $this->ui->outputData('WARNING: exclude tags are ignored in conversion');
+ }
+
+ if (isset($dep['min'])) {
+ $pf->addPackageDep($dep['name'], $dep['min'], 'ge');
+ }
+
+ if (isset($dep['max'])) {
+ $pf->addPackageDep($dep['name'], $dep['max'], 'le');
+ }
+ }
+ }
+
+ if (isset($deps['required']['extension'])) {
+ if (!isset($deps['required']['extension'][0])) {
+ $deps['required']['extension'] = array($deps['required']['extension']);
+ }
+
+ foreach ($deps['required']['extension'] as $dep) {
+ if (isset($dep['conflicts'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml . '"' .
+ ' contains conflicts dependency. Using a ' .
+ 'PEAR_PackageFileManager-based script is an option');
+ }
+
+ if (isset($dep['exclude'])) {
+ $this->ui->outputData('WARNING: exclude tags are ignored in conversion');
+ }
+
+ if (isset($dep['min'])) {
+ $pf->addExtensionDep($dep['name'], $dep['min'], 'ge');
+ }
+
+ if (isset($dep['max'])) {
+ $pf->addExtensionDep($dep['name'], $dep['max'], 'le');
+ }
+ }
+ }
+
+ if (isset($deps['optional']['package'])) {
+ if (!isset($deps['optional']['package'][0])) {
+ $deps['optional']['package'] = array($deps['optional']['package']);
+ }
+
+ foreach ($deps['optional']['package'] as $dep) {
+ if (!isset($dep['channel'])) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml . '"' .
+ ' contains uri-based dependency on a package. Using a ' .
+ 'PEAR_PackageFileManager-based script is an option');
+ }
+
+ if ($dep['channel'] != 'pear.php.net'
+ && $dep['channel'] != 'pecl.php.net'
+ && $dep['channel'] != 'doc.php.net') {
+ return $this->raiseError('Cannot safely convert "' . $packagexml . '"' .
+ ' contains dependency on a non-standard channel package. Using a ' .
+ 'PEAR_PackageFileManager-based script is an option');
+ }
+
+ if (isset($dep['exclude'])) {
+ $this->ui->outputData('WARNING: exclude tags are ignored in conversion');
+ }
+
+ if (isset($dep['min'])) {
+ $pf->addPackageDep($dep['name'], $dep['min'], 'ge', 'yes');
+ }
+
+ if (isset($dep['max'])) {
+ $pf->addPackageDep($dep['name'], $dep['max'], 'le', 'yes');
+ }
+ }
+ }
+
+ if (isset($deps['optional']['extension'])) {
+ if (!isset($deps['optional']['extension'][0])) {
+ $deps['optional']['extension'] = array($deps['optional']['extension']);
+ }
+
+ foreach ($deps['optional']['extension'] as $dep) {
+ if (isset($dep['exclude'])) {
+ $this->ui->outputData('WARNING: exclude tags are ignored in conversion');
+ }
+
+ if (isset($dep['min'])) {
+ $pf->addExtensionDep($dep['name'], $dep['min'], 'ge', 'yes');
+ }
+
+ if (isset($dep['max'])) {
+ $pf->addExtensionDep($dep['name'], $dep['max'], 'le', 'yes');
+ }
+ }
+ }
+
+ $contents = $pf2->getContents();
+ $release = $pf2->getReleases();
+ if (isset($releases[0])) {
+ return $this->raiseError('Cannot safely process "' . $packagexml . '" contains '
+ . 'multiple extsrcrelease/zendextsrcrelease tags. Using a PEAR_PackageFileManager-based script ' .
+ 'or the convert command is an option');
+ }
+
+ if ($configoptions = $pf2->getConfigureOptions()) {
+ foreach ($configoptions as $option) {
+ $default = isset($option['default']) ? $option['default'] : false;
+ $pf->addConfigureOption($option['name'], $option['prompt'], $default);
+ }
+ }
+
+ if (isset($release['filelist']['ignore'])) {
+ return $this->raiseError('Cannot safely process "' . $packagexml . '" contains '
+ . 'ignore tags. Using a PEAR_PackageFileManager-based script or the convert' .
+ ' command is an option');
+ }
+
+ if (isset($release['filelist']['install']) &&
+ !isset($release['filelist']['install'][0])) {
+ $release['filelist']['install'] = array($release['filelist']['install']);
+ }
+
+ if (isset($contents['dir']['attribs']['baseinstalldir'])) {
+ $baseinstalldir = $contents['dir']['attribs']['baseinstalldir'];
+ } else {
+ $baseinstalldir = false;
+ }
+
+ if (!isset($contents['dir']['file'][0])) {
+ $contents['dir']['file'] = array($contents['dir']['file']);
+ }
+
+ foreach ($contents['dir']['file'] as $file) {
+ if ($baseinstalldir && !isset($file['attribs']['baseinstalldir'])) {
+ $file['attribs']['baseinstalldir'] = $baseinstalldir;
+ }
+
+ $processFile = $file;
+ unset($processFile['attribs']);
+ if (count($processFile)) {
+ foreach ($processFile as $name => $task) {
+ if ($name != $pf2->getTasksNs() . ':replace') {
+ return $this->raiseError('Cannot safely process "' . $packagexml .
+ '" contains tasks other than replace. Using a ' .
+ 'PEAR_PackageFileManager-based script is an option.');
+ }
+ $file['attribs']['replace'][] = $task;
+ }
+ }
+
+ if (!in_array($file['attribs']['role'], PEAR_Common::getFileRoles())) {
+ return $this->raiseError('Cannot safely convert "' . $packagexml .
+ '", contains custom roles. Using a PEAR_PackageFileManager-based script ' .
+ 'or the convert command is an option');
+ }
+
+ if (isset($release['filelist']['install'])) {
+ foreach ($release['filelist']['install'] as $installas) {
+ if ($installas['attribs']['name'] == $file['attribs']['name']) {
+ $file['attribs']['install-as'] = $installas['attribs']['as'];
+ }
+ }
+ }
+
+ $pf->addFile('/', $file['attribs']['name'], $file['attribs']);
+ }
+
+ if ($pf2->getChangeLog()) {
+ $this->ui->outputData('WARNING: changelog is not translated to package.xml ' .
+ '1.0, use PEAR_PackageFileManager-based script if you need changelog-' .
+ 'translation for package.xml 1.0');
+ }
+
+ $gen = &$pf->getDefaultGenerator();
+ $gen->toPackageFile('.');
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Registry.xml 0000644 0001750 0000144 00000003376 12610427352 016344 0 ustar cweiske users
+
+ List Installed Packages In The Default Channel
+ doList
+ l
+
+
+ c
+ list installed packages from this channel
+ CHAN
+
+
+ a
+ list installed packages from all channels
+
+
+ i
+ output fully channel-aware data, even on failure
+
+
+ <package>
+If invoked without parameters, this command lists the PEAR packages
+installed in your php_dir ({config php_dir}). With a parameter, it
+lists the files in a package.
+
+
+
+ List Files In Installed Package
+ doFileList
+ fl
+
+ <package>
+List the files in an installed package.
+
+
+
+ Shell Script Test
+ doShellTest
+ st
+
+ <package> [[relation] version]
+Tests if a package is installed in the system. Will exit(1) if it is not.
+ <relation> The version comparison operator. One of:
+ <, lt, <=, le, >, gt, >=, ge, ==, =, eq, !=, <>, ne
+ <version> The version to compare with
+
+
+
+ Display information about a package
+ doInfo
+ in
+
+ <package>
+Displays information about a package. The package argument may be a
+local package file, an URL to a package file, or the name of an
+installed package.
+
+ PEAR-1.10.1/PEAR/Command/Registry.php 0000644 0001750 0000144 00000132262 12610427352 016330 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for registry manipulation
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Command_Registry extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'list' => array(
+ 'summary' => 'List Installed Packages In The Default Channel',
+ 'function' => 'doList',
+ 'shortcut' => 'l',
+ 'options' => array(
+ 'channel' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'list installed packages from this channel',
+ 'arg' => 'CHAN',
+ ),
+ 'allchannels' => array(
+ 'shortopt' => 'a',
+ 'doc' => 'list installed packages from all channels',
+ ),
+ 'channelinfo' => array(
+ 'shortopt' => 'i',
+ 'doc' => 'output fully channel-aware data, even on failure',
+ ),
+ ),
+ 'doc' => '
+If invoked without parameters, this command lists the PEAR packages
+installed in your php_dir ({config php_dir}). With a parameter, it
+lists the files in a package.
+',
+ ),
+ 'list-files' => array(
+ 'summary' => 'List Files In Installed Package',
+ 'function' => 'doFileList',
+ 'shortcut' => 'fl',
+ 'options' => array(),
+ 'doc' => '
+List the files in an installed package.
+'
+ ),
+ 'shell-test' => array(
+ 'summary' => 'Shell Script Test',
+ 'function' => 'doShellTest',
+ 'shortcut' => 'st',
+ 'options' => array(),
+ 'doc' => ' [[relation] version]
+Tests if a package is installed in the system. Will exit(1) if it is not.
+ The version comparison operator. One of:
+ <, lt, <=, le, >, gt, >=, ge, ==, =, eq, !=, <>, ne
+ The version to compare with
+'),
+ 'info' => array(
+ 'summary' => 'Display information about a package',
+ 'function' => 'doInfo',
+ 'shortcut' => 'in',
+ 'options' => array(),
+ 'doc' => '
+Displays information about a package. The package argument may be a
+local package file, an URL to a package file, or the name of an
+installed package.'
+ )
+ );
+
+ /**
+ * PEAR_Command_Registry constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ function _sortinfo($a, $b)
+ {
+ $apackage = isset($a['package']) ? $a['package'] : $a['name'];
+ $bpackage = isset($b['package']) ? $b['package'] : $b['name'];
+ return strcmp($apackage, $bpackage);
+ }
+
+ function doList($command, $options, $params)
+ {
+ $reg = &$this->config->getRegistry();
+ $channelinfo = isset($options['channelinfo']);
+ if (isset($options['allchannels']) && !$channelinfo) {
+ return $this->doListAll($command, array(), $params);
+ }
+
+ if (isset($options['allchannels']) && $channelinfo) {
+ // allchannels with $channelinfo
+ unset($options['allchannels']);
+ $channels = $reg->getChannels();
+ $errors = array();
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ foreach ($channels as $channel) {
+ $options['channel'] = $channel->getName();
+ $ret = $this->doList($command, $options, $params);
+
+ if (PEAR::isError($ret)) {
+ $errors[] = $ret;
+ }
+ }
+
+ PEAR::staticPopErrorHandling();
+ if (count($errors)) {
+ // for now, only give first error
+ return PEAR::raiseError($errors[0]);
+ }
+
+ return true;
+ }
+
+ if (count($params) === 1) {
+ return $this->doFileList($command, $options, $params);
+ }
+
+ if (isset($options['channel'])) {
+ if (!$reg->channelExists($options['channel'])) {
+ return $this->raiseError('Channel "' . $options['channel'] .'" does not exist');
+ }
+
+ $channel = $reg->channelName($options['channel']);
+ } else {
+ $channel = $this->config->get('default_channel');
+ }
+
+ $installed = $reg->packageInfo(null, null, $channel);
+ usort($installed, array(&$this, '_sortinfo'));
+
+ $data = array(
+ 'caption' => 'Installed packages, channel ' .
+ $channel . ':',
+ 'border' => true,
+ 'headline' => array('Package', 'Version', 'State'),
+ 'channel' => $channel,
+ );
+ if ($channelinfo) {
+ $data['headline'] = array('Channel', 'Package', 'Version', 'State');
+ }
+
+ if (count($installed) && !isset($data['data'])) {
+ $data['data'] = array();
+ }
+
+ foreach ($installed as $package) {
+ $pobj = $reg->getPackage(isset($package['package']) ?
+ $package['package'] : $package['name'], $channel);
+ if ($channelinfo) {
+ $packageinfo = array($pobj->getChannel(), $pobj->getPackage(), $pobj->getVersion(),
+ $pobj->getState() ? $pobj->getState() : null);
+ } else {
+ $packageinfo = array($pobj->getPackage(), $pobj->getVersion(),
+ $pobj->getState() ? $pobj->getState() : null);
+ }
+ $data['data'][] = $packageinfo;
+ }
+
+ if (count($installed) === 0) {
+ if (!$channelinfo) {
+ $data = '(no packages installed from channel ' . $channel . ')';
+ } else {
+ $data = array(
+ 'caption' => 'Installed packages, channel ' .
+ $channel . ':',
+ 'border' => true,
+ 'channel' => $channel,
+ 'data' => array(array('(no packages installed)')),
+ );
+ }
+ }
+
+ $this->ui->outputData($data, $command);
+ return true;
+ }
+
+ function doListAll($command, $options, $params)
+ {
+ // This duplicate code is deprecated over
+ // list --channelinfo, which gives identical
+ // output for list and list --allchannels.
+ $reg = &$this->config->getRegistry();
+ $installed = $reg->packageInfo(null, null, null);
+ foreach ($installed as $channel => $packages) {
+ usort($packages, array($this, '_sortinfo'));
+ $data = array(
+ 'caption' => 'Installed packages, channel ' . $channel . ':',
+ 'border' => true,
+ 'headline' => array('Package', 'Version', 'State'),
+ 'channel' => $channel
+ );
+
+ foreach ($packages as $package) {
+ $p = isset($package['package']) ? $package['package'] : $package['name'];
+ $pobj = $reg->getPackage($p, $channel);
+ $data['data'][] = array($pobj->getPackage(), $pobj->getVersion(),
+ $pobj->getState() ? $pobj->getState() : null);
+ }
+
+ // Adds a blank line after each section
+ $data['data'][] = array();
+
+ if (count($packages) === 0) {
+ $data = array(
+ 'caption' => 'Installed packages, channel ' . $channel . ':',
+ 'border' => true,
+ 'data' => array(array('(no packages installed)'), array()),
+ 'channel' => $channel
+ );
+ }
+ $this->ui->outputData($data, $command);
+ }
+ return true;
+ }
+
+ function doFileList($command, $options, $params)
+ {
+ if (count($params) !== 1) {
+ return $this->raiseError('list-files expects 1 parameter');
+ }
+
+ $reg = &$this->config->getRegistry();
+ $fp = false;
+ if (!is_dir($params[0]) && (file_exists($params[0]) || $fp = @fopen($params[0], 'r'))) {
+ if ($fp) {
+ fclose($fp);
+ }
+
+ if (!class_exists('PEAR_PackageFile')) {
+ require_once 'PEAR/PackageFile.php';
+ }
+
+ $pkg = new PEAR_PackageFile($this->config, $this->_debug);
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $info = &$pkg->fromAnyFile($params[0], PEAR_VALIDATE_NORMAL);
+ PEAR::staticPopErrorHandling();
+ $headings = array('Package File', 'Install Path');
+ $installed = false;
+ } else {
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $parsed = $reg->parsePackageName($params[0], $this->config->get('default_channel'));
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($parsed)) {
+ return $this->raiseError($parsed);
+ }
+
+ $info = &$reg->getPackage($parsed['package'], $parsed['channel']);
+ $headings = array('Type', 'Install Path');
+ $installed = true;
+ }
+
+ if (PEAR::isError($info)) {
+ return $this->raiseError($info);
+ }
+
+ if ($info === null) {
+ return $this->raiseError("`$params[0]' not installed");
+ }
+
+ $list = ($info->getPackagexmlVersion() == '1.0' || $installed) ?
+ $info->getFilelist() : $info->getContents();
+ if ($installed) {
+ $caption = 'Installed Files For ' . $params[0];
+ } else {
+ $caption = 'Contents of ' . basename($params[0]);
+ }
+
+ $data = array(
+ 'caption' => $caption,
+ 'border' => true,
+ 'headline' => $headings);
+ if ($info->getPackagexmlVersion() == '1.0' || $installed) {
+ foreach ($list as $file => $att) {
+ if ($installed) {
+ if (empty($att['installed_as'])) {
+ continue;
+ }
+ $data['data'][] = array($att['role'], $att['installed_as']);
+ } else {
+ if (isset($att['baseinstalldir']) && !in_array($att['role'],
+ array('test', 'data', 'doc'))) {
+ $dest = $att['baseinstalldir'] . DIRECTORY_SEPARATOR .
+ $file;
+ } else {
+ $dest = $file;
+ }
+ switch ($att['role']) {
+ case 'test':
+ case 'data':
+ case 'doc':
+ $role = $att['role'];
+ if ($role == 'test') {
+ $role .= 's';
+ }
+ $dest = $this->config->get($role . '_dir') . DIRECTORY_SEPARATOR .
+ $info->getPackage() . DIRECTORY_SEPARATOR . $dest;
+ break;
+ case 'php':
+ default:
+ $dest = $this->config->get('php_dir') . DIRECTORY_SEPARATOR .
+ $dest;
+ }
+ $ds2 = DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR;
+ $dest = preg_replace(array('!\\\\+!', '!/!', "!$ds2+!"),
+ array(DIRECTORY_SEPARATOR,
+ DIRECTORY_SEPARATOR,
+ DIRECTORY_SEPARATOR),
+ $dest);
+ $file = preg_replace('!/+!', '/', $file);
+ $data['data'][] = array($file, $dest);
+ }
+ }
+ } else { // package.xml 2.0, not installed
+ if (!isset($list['dir']['file'][0])) {
+ $list['dir']['file'] = array($list['dir']['file']);
+ }
+
+ foreach ($list['dir']['file'] as $att) {
+ $att = $att['attribs'];
+ $file = $att['name'];
+ $role = &PEAR_Installer_Role::factory($info, $att['role'], $this->config);
+ $role->setup($this, $info, $att, $file);
+ if (!$role->isInstallable()) {
+ $dest = '(not installable)';
+ } else {
+ $dest = $role->processInstallation($info, $att, $file, '');
+ if (PEAR::isError($dest)) {
+ $dest = '(Unknown role "' . $att['role'] . ')';
+ } else {
+ list(,, $dest) = $dest;
+ }
+ }
+ $data['data'][] = array($file, $dest);
+ }
+ }
+
+ $this->ui->outputData($data, $command);
+ return true;
+ }
+
+ function doShellTest($command, $options, $params)
+ {
+ if (count($params) < 1) {
+ return PEAR::raiseError('ERROR, usage: pear shell-test packagename [[relation] version]');
+ }
+
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $reg = &$this->config->getRegistry();
+ $info = $reg->parsePackageName($params[0], $this->config->get('default_channel'));
+ if (PEAR::isError($info)) {
+ exit(1); // invalid package name
+ }
+
+ $package = $info['package'];
+ $channel = $info['channel'];
+ // "pear shell-test Foo"
+ if (!$reg->packageExists($package, $channel)) {
+ if ($channel == 'pecl.php.net') {
+ if ($reg->packageExists($package, 'pear.php.net')) {
+ $channel = 'pear.php.net'; // magically change channels for extensions
+ }
+ }
+ }
+
+ if (count($params) === 1) {
+ if (!$reg->packageExists($package, $channel)) {
+ exit(1);
+ }
+ // "pear shell-test Foo 1.0"
+ } elseif (count($params) === 2) {
+ $v = $reg->packageInfo($package, 'version', $channel);
+ if (!$v || !version_compare("$v", "{$params[1]}", "ge")) {
+ exit(1);
+ }
+ // "pear shell-test Foo ge 1.0"
+ } elseif (count($params) === 3) {
+ $v = $reg->packageInfo($package, 'version', $channel);
+ if (!$v || !version_compare("$v", "{$params[2]}", $params[1])) {
+ exit(1);
+ }
+ } else {
+ PEAR::staticPopErrorHandling();
+ $this->raiseError("$command: expects 1 to 3 parameters");
+ exit(1);
+ }
+ }
+
+ function doInfo($command, $options, $params)
+ {
+ if (count($params) !== 1) {
+ return $this->raiseError('pear info expects 1 parameter');
+ }
+
+ $info = $fp = false;
+ $reg = &$this->config->getRegistry();
+ if (is_file($params[0]) && !is_dir($params[0]) &&
+ (file_exists($params[0]) || $fp = @fopen($params[0], 'r'))
+ ) {
+ if ($fp) {
+ fclose($fp);
+ }
+
+ if (!class_exists('PEAR_PackageFile')) {
+ require_once 'PEAR/PackageFile.php';
+ }
+
+ $pkg = new PEAR_PackageFile($this->config, $this->_debug);
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $obj = &$pkg->fromAnyFile($params[0], PEAR_VALIDATE_NORMAL);
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($obj)) {
+ $uinfo = $obj->getUserInfo();
+ if (is_array($uinfo)) {
+ foreach ($uinfo as $message) {
+ if (is_array($message)) {
+ $message = $message['message'];
+ }
+ $this->ui->outputData($message);
+ }
+ }
+
+ return $this->raiseError($obj);
+ }
+
+ if ($obj->getPackagexmlVersion() != '1.0') {
+ return $this->_doInfo2($command, $options, $params, $obj, false);
+ }
+
+ $info = $obj->toArray();
+ } else {
+ $parsed = $reg->parsePackageName($params[0], $this->config->get('default_channel'));
+ if (PEAR::isError($parsed)) {
+ return $this->raiseError($parsed);
+ }
+
+ $package = $parsed['package'];
+ $channel = $parsed['channel'];
+ $info = $reg->packageInfo($package, null, $channel);
+ if (isset($info['old'])) {
+ $obj = $reg->getPackage($package, $channel);
+ return $this->_doInfo2($command, $options, $params, $obj, true);
+ }
+ }
+
+ if (PEAR::isError($info)) {
+ return $info;
+ }
+
+ if (empty($info)) {
+ $this->raiseError("No information found for `$params[0]'");
+ return;
+ }
+
+ unset($info['filelist']);
+ unset($info['dirtree']);
+ unset($info['changelog']);
+ if (isset($info['xsdversion'])) {
+ $info['package.xml version'] = $info['xsdversion'];
+ unset($info['xsdversion']);
+ }
+
+ if (isset($info['packagerversion'])) {
+ $info['packaged with PEAR version'] = $info['packagerversion'];
+ unset($info['packagerversion']);
+ }
+
+ $keys = array_keys($info);
+ $longtext = array('description', 'summary');
+ foreach ($keys as $key) {
+ if (is_array($info[$key])) {
+ switch ($key) {
+ case 'maintainers': {
+ $i = 0;
+ $mstr = '';
+ foreach ($info[$key] as $m) {
+ if ($i++ > 0) {
+ $mstr .= "\n";
+ }
+ $mstr .= $m['name'] . " <";
+ if (isset($m['email'])) {
+ $mstr .= $m['email'];
+ } else {
+ $mstr .= $m['handle'] . '@php.net';
+ }
+ $mstr .= "> ($m[role])";
+ }
+ $info[$key] = $mstr;
+ break;
+ }
+ case 'release_deps': {
+ $i = 0;
+ $dstr = '';
+ foreach ($info[$key] as $d) {
+ if (isset($this->_deps_rel_trans[$d['rel']])) {
+ $rel = $this->_deps_rel_trans[$d['rel']];
+ } else {
+ $rel = $d['rel'];
+ }
+ if (isset($this->_deps_type_trans[$d['type']])) {
+ $type = ucfirst($this->_deps_type_trans[$d['type']]);
+ } else {
+ $type = $d['type'];
+ }
+ if (isset($d['name'])) {
+ $name = $d['name'] . ' ';
+ } else {
+ $name = '';
+ }
+ if (isset($d['version'])) {
+ $version = $d['version'] . ' ';
+ } else {
+ $version = '';
+ }
+ if (isset($d['optional']) && $d['optional'] == 'yes') {
+ $optional = ' (optional)';
+ } else {
+ $optional = '';
+ }
+ $dstr .= "$type $name$rel $version$optional\n";
+ }
+ $info[$key] = $dstr;
+ break;
+ }
+ case 'provides' : {
+ $debug = $this->config->get('verbose');
+ if ($debug < 2) {
+ $pstr = 'Classes: ';
+ } else {
+ $pstr = '';
+ }
+ $i = 0;
+ foreach ($info[$key] as $p) {
+ if ($debug < 2 && $p['type'] != "class") {
+ continue;
+ }
+ // Only print classes when verbosity mode is < 2
+ if ($debug < 2) {
+ if ($i++ > 0) {
+ $pstr .= ", ";
+ }
+ $pstr .= $p['name'];
+ } else {
+ if ($i++ > 0) {
+ $pstr .= "\n";
+ }
+ $pstr .= ucfirst($p['type']) . " " . $p['name'];
+ if (isset($p['explicit']) && $p['explicit'] == 1) {
+ $pstr .= " (explicit)";
+ }
+ }
+ }
+ $info[$key] = $pstr;
+ break;
+ }
+ case 'configure_options' : {
+ foreach ($info[$key] as $i => $p) {
+ $info[$key][$i] = array_map(null, array_keys($p), array_values($p));
+ $info[$key][$i] = array_map(create_function('$a',
+ 'return join(" = ",$a);'), $info[$key][$i]);
+ $info[$key][$i] = implode(', ', $info[$key][$i]);
+ }
+ $info[$key] = implode("\n", $info[$key]);
+ break;
+ }
+ default: {
+ $info[$key] = implode(", ", $info[$key]);
+ break;
+ }
+ }
+ }
+
+ if ($key == '_lastmodified') {
+ $hdate = date('Y-m-d', $info[$key]);
+ unset($info[$key]);
+ $info['Last Modified'] = $hdate;
+ } elseif ($key == '_lastversion') {
+ $info['Previous Installed Version'] = $info[$key] ? $info[$key] : '- None -';
+ unset($info[$key]);
+ } else {
+ $info[$key] = trim($info[$key]);
+ if (in_array($key, $longtext)) {
+ $info[$key] = preg_replace('/ +/', ' ', $info[$key]);
+ }
+ }
+ }
+
+ $caption = 'About ' . $info['package'] . '-' . $info['version'];
+ $data = array(
+ 'caption' => $caption,
+ 'border' => true);
+ foreach ($info as $key => $value) {
+ $key = ucwords(trim(str_replace('_', ' ', $key)));
+ $data['data'][] = array($key, $value);
+ }
+ $data['raw'] = $info;
+
+ $this->ui->outputData($data, 'package-info');
+ }
+
+ /**
+ * @access private
+ */
+ function _doInfo2($command, $options, $params, &$obj, $installed)
+ {
+ $reg = &$this->config->getRegistry();
+ $caption = 'About ' . $obj->getChannel() . '/' .$obj->getPackage() . '-' .
+ $obj->getVersion();
+ $data = array(
+ 'caption' => $caption,
+ 'border' => true);
+ switch ($obj->getPackageType()) {
+ case 'php' :
+ $release = 'PEAR-style PHP-based Package';
+ break;
+ case 'extsrc' :
+ $release = 'PECL-style PHP extension (source code)';
+ break;
+ case 'zendextsrc' :
+ $release = 'PECL-style Zend extension (source code)';
+ break;
+ case 'extbin' :
+ $release = 'PECL-style PHP extension (binary)';
+ break;
+ case 'zendextbin' :
+ $release = 'PECL-style Zend extension (binary)';
+ break;
+ case 'bundle' :
+ $release = 'Package bundle (collection of packages)';
+ break;
+ }
+ $extends = $obj->getExtends();
+ $extends = $extends ?
+ $obj->getPackage() . ' (extends ' . $extends . ')' : $obj->getPackage();
+ if ($src = $obj->getSourcePackage()) {
+ $extends .= ' (source package ' . $src['channel'] . '/' . $src['package'] . ')';
+ }
+
+ $info = array(
+ 'Release Type' => $release,
+ 'Name' => $extends,
+ 'Channel' => $obj->getChannel(),
+ 'Summary' => preg_replace('/ +/', ' ', $obj->getSummary()),
+ 'Description' => preg_replace('/ +/', ' ', $obj->getDescription()),
+ );
+ $info['Maintainers'] = '';
+ foreach (array('lead', 'developer', 'contributor', 'helper') as $role) {
+ $leads = $obj->{"get{$role}s"}();
+ if (!$leads) {
+ continue;
+ }
+
+ if (isset($leads['active'])) {
+ $leads = array($leads);
+ }
+
+ foreach ($leads as $lead) {
+ if (!empty($info['Maintainers'])) {
+ $info['Maintainers'] .= "\n";
+ }
+
+ $active = $lead['active'] == 'no' ? ', inactive' : '';
+ $info['Maintainers'] .= $lead['name'] . ' <';
+ $info['Maintainers'] .= $lead['email'] . "> ($role$active)";
+ }
+ }
+
+ $info['Release Date'] = $obj->getDate();
+ if ($time = $obj->getTime()) {
+ $info['Release Date'] .= ' ' . $time;
+ }
+
+ $info['Release Version'] = $obj->getVersion() . ' (' . $obj->getState() . ')';
+ $info['API Version'] = $obj->getVersion('api') . ' (' . $obj->getState('api') . ')';
+ $info['License'] = $obj->getLicense();
+ $uri = $obj->getLicenseLocation();
+ if ($uri) {
+ if (isset($uri['uri'])) {
+ $info['License'] .= ' (' . $uri['uri'] . ')';
+ } else {
+ $extra = $obj->getInstalledLocation($info['filesource']);
+ if ($extra) {
+ $info['License'] .= ' (' . $uri['filesource'] . ')';
+ }
+ }
+ }
+
+ $info['Release Notes'] = $obj->getNotes();
+ if ($compat = $obj->getCompatible()) {
+ if (!isset($compat[0])) {
+ $compat = array($compat);
+ }
+
+ $info['Compatible with'] = '';
+ foreach ($compat as $package) {
+ $info['Compatible with'] .= $package['channel'] . '/' . $package['name'] .
+ "\nVersions >= " . $package['min'] . ', <= ' . $package['max'];
+ if (isset($package['exclude'])) {
+ if (is_array($package['exclude'])) {
+ $package['exclude'] = implode(', ', $package['exclude']);
+ }
+
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+ $info['Not Compatible with'] .= $package['channel'] . '/' .
+ $package['name'] . "\nVersions " . $package['exclude'];
+ }
+ }
+ }
+
+ $usesrole = $obj->getUsesrole();
+ if ($usesrole) {
+ if (!isset($usesrole[0])) {
+ $usesrole = array($usesrole);
+ }
+
+ foreach ($usesrole as $roledata) {
+ if (isset($info['Uses Custom Roles'])) {
+ $info['Uses Custom Roles'] .= "\n";
+ } else {
+ $info['Uses Custom Roles'] = '';
+ }
+
+ if (isset($roledata['package'])) {
+ $rolepackage = $reg->parsedPackageNameToString($roledata, true);
+ } else {
+ $rolepackage = $roledata['uri'];
+ }
+ $info['Uses Custom Roles'] .= $roledata['role'] . ' (' . $rolepackage . ')';
+ }
+ }
+
+ $usestask = $obj->getUsestask();
+ if ($usestask) {
+ if (!isset($usestask[0])) {
+ $usestask = array($usestask);
+ }
+
+ foreach ($usestask as $taskdata) {
+ if (isset($info['Uses Custom Tasks'])) {
+ $info['Uses Custom Tasks'] .= "\n";
+ } else {
+ $info['Uses Custom Tasks'] = '';
+ }
+
+ if (isset($taskdata['package'])) {
+ $taskpackage = $reg->parsedPackageNameToString($taskdata, true);
+ } else {
+ $taskpackage = $taskdata['uri'];
+ }
+ $info['Uses Custom Tasks'] .= $taskdata['task'] . ' (' . $taskpackage . ')';
+ }
+ }
+
+ $deps = $obj->getDependencies();
+ $info['Required Dependencies'] = 'PHP version ' . $deps['required']['php']['min'];
+ if (isset($deps['required']['php']['max'])) {
+ $info['Required Dependencies'] .= '-' . $deps['required']['php']['max'] . "\n";
+ } else {
+ $info['Required Dependencies'] .= "\n";
+ }
+
+ if (isset($deps['required']['php']['exclude'])) {
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+
+ if (is_array($deps['required']['php']['exclude'])) {
+ $deps['required']['php']['exclude'] =
+ implode(', ', $deps['required']['php']['exclude']);
+ }
+ $info['Not Compatible with'] .= "PHP versions\n " .
+ $deps['required']['php']['exclude'];
+ }
+
+ $info['Required Dependencies'] .= 'PEAR installer version';
+ if (isset($deps['required']['pearinstaller']['max'])) {
+ $info['Required Dependencies'] .= 's ' .
+ $deps['required']['pearinstaller']['min'] . '-' .
+ $deps['required']['pearinstaller']['max'];
+ } else {
+ $info['Required Dependencies'] .= ' ' .
+ $deps['required']['pearinstaller']['min'] . ' or newer';
+ }
+
+ if (isset($deps['required']['pearinstaller']['exclude'])) {
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+
+ if (is_array($deps['required']['pearinstaller']['exclude'])) {
+ $deps['required']['pearinstaller']['exclude'] =
+ implode(', ', $deps['required']['pearinstaller']['exclude']);
+ }
+ $info['Not Compatible with'] .= "PEAR installer\n Versions " .
+ $deps['required']['pearinstaller']['exclude'];
+ }
+
+ foreach (array('Package', 'Extension') as $type) {
+ $index = strtolower($type);
+ if (isset($deps['required'][$index])) {
+ if (isset($deps['required'][$index]['name'])) {
+ $deps['required'][$index] = array($deps['required'][$index]);
+ }
+
+ foreach ($deps['required'][$index] as $package) {
+ if (isset($package['conflicts'])) {
+ $infoindex = 'Not Compatible with';
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+ } else {
+ $infoindex = 'Required Dependencies';
+ $info[$infoindex] .= "\n";
+ }
+
+ if ($index == 'extension') {
+ $name = $package['name'];
+ } else {
+ if (isset($package['channel'])) {
+ $name = $package['channel'] . '/' . $package['name'];
+ } else {
+ $name = '__uri/' . $package['name'] . ' (static URI)';
+ }
+ }
+
+ $info[$infoindex] .= "$type $name";
+ if (isset($package['uri'])) {
+ $info[$infoindex] .= "\n Download URI: $package[uri]";
+ continue;
+ }
+
+ if (isset($package['max']) && isset($package['min'])) {
+ $info[$infoindex] .= " \n Versions " .
+ $package['min'] . '-' . $package['max'];
+ } elseif (isset($package['min'])) {
+ $info[$infoindex] .= " \n Version " .
+ $package['min'] . ' or newer';
+ } elseif (isset($package['max'])) {
+ $info[$infoindex] .= " \n Version " .
+ $package['max'] . ' or older';
+ }
+
+ if (isset($package['recommended'])) {
+ $info[$infoindex] .= "\n Recommended version: $package[recommended]";
+ }
+
+ if (isset($package['exclude'])) {
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+
+ if (is_array($package['exclude'])) {
+ $package['exclude'] = implode(', ', $package['exclude']);
+ }
+
+ $package['package'] = $package['name']; // for parsedPackageNameToString
+ if (isset($package['conflicts'])) {
+ $info['Not Compatible with'] .= '=> except ';
+ }
+ $info['Not Compatible with'] .= 'Package ' .
+ $reg->parsedPackageNameToString($package, true);
+ $info['Not Compatible with'] .= "\n Versions " . $package['exclude'];
+ }
+ }
+ }
+ }
+
+ if (isset($deps['required']['os'])) {
+ if (isset($deps['required']['os']['name'])) {
+ $dep['required']['os']['name'] = array($dep['required']['os']['name']);
+ }
+
+ foreach ($dep['required']['os'] as $os) {
+ if (isset($os['conflicts']) && $os['conflicts'] == 'yes') {
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+ $info['Not Compatible with'] .= "$os[name] Operating System";
+ } else {
+ $info['Required Dependencies'] .= "\n";
+ $info['Required Dependencies'] .= "$os[name] Operating System";
+ }
+ }
+ }
+
+ if (isset($deps['required']['arch'])) {
+ if (isset($deps['required']['arch']['pattern'])) {
+ $dep['required']['arch']['pattern'] = array($dep['required']['os']['pattern']);
+ }
+
+ foreach ($dep['required']['arch'] as $os) {
+ if (isset($os['conflicts']) && $os['conflicts'] == 'yes') {
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+ $info['Not Compatible with'] .= "OS/Arch matching pattern '/$os[pattern]/'";
+ } else {
+ $info['Required Dependencies'] .= "\n";
+ $info['Required Dependencies'] .= "OS/Arch matching pattern '/$os[pattern]/'";
+ }
+ }
+ }
+
+ if (isset($deps['optional'])) {
+ foreach (array('Package', 'Extension') as $type) {
+ $index = strtolower($type);
+ if (isset($deps['optional'][$index])) {
+ if (isset($deps['optional'][$index]['name'])) {
+ $deps['optional'][$index] = array($deps['optional'][$index]);
+ }
+
+ foreach ($deps['optional'][$index] as $package) {
+ if (isset($package['conflicts']) && $package['conflicts'] == 'yes') {
+ $infoindex = 'Not Compatible with';
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+ } else {
+ $infoindex = 'Optional Dependencies';
+ if (!isset($info['Optional Dependencies'])) {
+ $info['Optional Dependencies'] = '';
+ } else {
+ $info['Optional Dependencies'] .= "\n";
+ }
+ }
+
+ if ($index == 'extension') {
+ $name = $package['name'];
+ } else {
+ if (isset($package['channel'])) {
+ $name = $package['channel'] . '/' . $package['name'];
+ } else {
+ $name = '__uri/' . $package['name'] . ' (static URI)';
+ }
+ }
+
+ $info[$infoindex] .= "$type $name";
+ if (isset($package['uri'])) {
+ $info[$infoindex] .= "\n Download URI: $package[uri]";
+ continue;
+ }
+
+ if ($infoindex == 'Not Compatible with') {
+ // conflicts is only used to say that all versions conflict
+ continue;
+ }
+
+ if (isset($package['max']) && isset($package['min'])) {
+ $info[$infoindex] .= " \n Versions " .
+ $package['min'] . '-' . $package['max'];
+ } elseif (isset($package['min'])) {
+ $info[$infoindex] .= " \n Version " .
+ $package['min'] . ' or newer';
+ } elseif (isset($package['max'])) {
+ $info[$infoindex] .= " \n Version " .
+ $package['min'] . ' or older';
+ }
+
+ if (isset($package['recommended'])) {
+ $info[$infoindex] .= "\n Recommended version: $package[recommended]";
+ }
+
+ if (isset($package['exclude'])) {
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info['Not Compatible with'] .= "\n";
+ }
+
+ if (is_array($package['exclude'])) {
+ $package['exclude'] = implode(', ', $package['exclude']);
+ }
+
+ $info['Not Compatible with'] .= "Package $package\n Versions " .
+ $package['exclude'];
+ }
+ }
+ }
+ }
+ }
+
+ if (isset($deps['group'])) {
+ if (!isset($deps['group'][0])) {
+ $deps['group'] = array($deps['group']);
+ }
+
+ foreach ($deps['group'] as $group) {
+ $info['Dependency Group ' . $group['attribs']['name']] = $group['attribs']['hint'];
+ $groupindex = $group['attribs']['name'] . ' Contents';
+ $info[$groupindex] = '';
+ foreach (array('Package', 'Extension') as $type) {
+ $index = strtolower($type);
+ if (isset($group[$index])) {
+ if (isset($group[$index]['name'])) {
+ $group[$index] = array($group[$index]);
+ }
+
+ foreach ($group[$index] as $package) {
+ if (!empty($info[$groupindex])) {
+ $info[$groupindex] .= "\n";
+ }
+
+ if ($index == 'extension') {
+ $name = $package['name'];
+ } else {
+ if (isset($package['channel'])) {
+ $name = $package['channel'] . '/' . $package['name'];
+ } else {
+ $name = '__uri/' . $package['name'] . ' (static URI)';
+ }
+ }
+
+ if (isset($package['uri'])) {
+ if (isset($package['conflicts']) && $package['conflicts'] == 'yes') {
+ $info[$groupindex] .= "Not Compatible with $type $name";
+ } else {
+ $info[$groupindex] .= "$type $name";
+ }
+
+ $info[$groupindex] .= "\n Download URI: $package[uri]";
+ continue;
+ }
+
+ if (isset($package['conflicts']) && $package['conflicts'] == 'yes') {
+ $info[$groupindex] .= "Not Compatible with $type $name";
+ continue;
+ }
+
+ $info[$groupindex] .= "$type $name";
+ if (isset($package['max']) && isset($package['min'])) {
+ $info[$groupindex] .= " \n Versions " .
+ $package['min'] . '-' . $package['max'];
+ } elseif (isset($package['min'])) {
+ $info[$groupindex] .= " \n Version " .
+ $package['min'] . ' or newer';
+ } elseif (isset($package['max'])) {
+ $info[$groupindex] .= " \n Version " .
+ $package['min'] . ' or older';
+ }
+
+ if (isset($package['recommended'])) {
+ $info[$groupindex] .= "\n Recommended version: $package[recommended]";
+ }
+
+ if (isset($package['exclude'])) {
+ if (!isset($info['Not Compatible with'])) {
+ $info['Not Compatible with'] = '';
+ } else {
+ $info[$groupindex] .= "Not Compatible with\n";
+ }
+
+ if (is_array($package['exclude'])) {
+ $package['exclude'] = implode(', ', $package['exclude']);
+ }
+ $info[$groupindex] .= " Package $package\n Versions " .
+ $package['exclude'];
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if ($obj->getPackageType() == 'bundle') {
+ $info['Bundled Packages'] = '';
+ foreach ($obj->getBundledPackages() as $package) {
+ if (!empty($info['Bundled Packages'])) {
+ $info['Bundled Packages'] .= "\n";
+ }
+
+ if (isset($package['uri'])) {
+ $info['Bundled Packages'] .= '__uri/' . $package['name'];
+ $info['Bundled Packages'] .= "\n (URI: $package[uri]";
+ } else {
+ $info['Bundled Packages'] .= $package['channel'] . '/' . $package['name'];
+ }
+ }
+ }
+
+ $info['package.xml version'] = '2.0';
+ if ($installed) {
+ if ($obj->getLastModified()) {
+ $info['Last Modified'] = date('Y-m-d H:i', $obj->getLastModified());
+ }
+
+ $v = $obj->getLastInstalledVersion();
+ $info['Previous Installed Version'] = $v ? $v : '- None -';
+ }
+
+ foreach ($info as $key => $value) {
+ $data['data'][] = array($key, $value);
+ }
+
+ $data['raw'] = $obj->getArray(); // no validation needed
+ $this->ui->outputData($data, 'package-info');
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Remote.xml 0000644 0001750 0000144 00000006357 12610427352 015771 0 ustar cweiske users
+
+ Information About Remote Packages
+ doRemoteInfo
+ ri
+
+ <package>
+Get details on a package from the server.
+
+
+ List Available Upgrades
+ doListUpgrades
+ lu
+
+
+ i
+ output fully channel-aware data, even on failure
+
+
+ [preferred_state]
+List releases on the server of packages you have installed where
+a newer version is available with the same release state (stable etc.)
+or the state passed as the second parameter.
+
+
+ List Remote Packages
+ doRemoteList
+ rl
+
+
+ c
+ specify a channel other than the default channel
+ CHAN
+
+
+
+Lists the packages available on the configured server along with the
+latest stable release of each package.
+
+
+ Search remote package database
+ doSearch
+ sp
+
+
+ c
+ specify a channel other than the default channel
+ CHAN
+
+
+ a
+ search packages from all known channels
+
+
+ i
+ output fully channel-aware data, even on failure
+
+
+ [packagename] [packageinfo]
+Lists all packages which match the search parameters. The first
+parameter is a fragment of a packagename. The default channel
+will be used unless explicitly overridden. The second parameter
+will be used to match any portion of the summary/description
+
+
+ List All Packages
+ doListAll
+ la
+
+
+ c
+ specify a channel other than the default channel
+ CHAN
+
+
+ i
+ output fully channel-aware data, even on failure
+
+
+
+Lists the packages available on the configured server along with the
+latest stable release of each package.
+
+
+ Download Package
+ doDownload
+ d
+
+
+ Z
+ download an uncompressed (.tar) file
+
+
+ <package>...
+Download package tarballs. The files will be named as suggested by the
+server, for example if you download the DB package and the latest stable
+version of DB is 1.6.5, the downloaded file will be DB-1.6.5.tgz.
+
+
+ Clear Web Services Cache
+ doClearCache
+ cc
+
+
+Clear the XML-RPC/REST cache. See also the cache_ttl configuration
+parameter.
+
+
+ PEAR-1.10.1/PEAR/Command/Remote.php 0000644 0001750 0000144 00000072435 12610427352 015760 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+require_once 'PEAR/REST.php';
+
+/**
+ * PEAR commands for remote server querying
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Command_Remote extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'remote-info' => array(
+ 'summary' => 'Information About Remote Packages',
+ 'function' => 'doRemoteInfo',
+ 'shortcut' => 'ri',
+ 'options' => array(),
+ 'doc' => '
+Get details on a package from the server.',
+ ),
+ 'list-upgrades' => array(
+ 'summary' => 'List Available Upgrades',
+ 'function' => 'doListUpgrades',
+ 'shortcut' => 'lu',
+ 'options' => array(
+ 'channelinfo' => array(
+ 'shortopt' => 'i',
+ 'doc' => 'output fully channel-aware data, even on failure',
+ ),
+ ),
+ 'doc' => '[preferred_state]
+List releases on the server of packages you have installed where
+a newer version is available with the same release state (stable etc.)
+or the state passed as the second parameter.'
+ ),
+ 'remote-list' => array(
+ 'summary' => 'List Remote Packages',
+ 'function' => 'doRemoteList',
+ 'shortcut' => 'rl',
+ 'options' => array(
+ 'channel' =>
+ array(
+ 'shortopt' => 'c',
+ 'doc' => 'specify a channel other than the default channel',
+ 'arg' => 'CHAN',
+ )
+ ),
+ 'doc' => '
+Lists the packages available on the configured server along with the
+latest stable release of each package.',
+ ),
+ 'search' => array(
+ 'summary' => 'Search remote package database',
+ 'function' => 'doSearch',
+ 'shortcut' => 'sp',
+ 'options' => array(
+ 'channel' =>
+ array(
+ 'shortopt' => 'c',
+ 'doc' => 'specify a channel other than the default channel',
+ 'arg' => 'CHAN',
+ ),
+ 'allchannels' => array(
+ 'shortopt' => 'a',
+ 'doc' => 'search packages from all known channels',
+ ),
+ 'channelinfo' => array(
+ 'shortopt' => 'i',
+ 'doc' => 'output fully channel-aware data, even on failure',
+ ),
+ ),
+ 'doc' => '[packagename] [packageinfo]
+Lists all packages which match the search parameters. The first
+parameter is a fragment of a packagename. The default channel
+will be used unless explicitly overridden. The second parameter
+will be used to match any portion of the summary/description',
+ ),
+ 'list-all' => array(
+ 'summary' => 'List All Packages',
+ 'function' => 'doListAll',
+ 'shortcut' => 'la',
+ 'options' => array(
+ 'channel' =>
+ array(
+ 'shortopt' => 'c',
+ 'doc' => 'specify a channel other than the default channel',
+ 'arg' => 'CHAN',
+ ),
+ 'channelinfo' => array(
+ 'shortopt' => 'i',
+ 'doc' => 'output fully channel-aware data, even on failure',
+ ),
+ ),
+ 'doc' => '
+Lists the packages available on the configured server along with the
+latest stable release of each package.',
+ ),
+ 'download' => array(
+ 'summary' => 'Download Package',
+ 'function' => 'doDownload',
+ 'shortcut' => 'd',
+ 'options' => array(
+ 'nocompress' => array(
+ 'shortopt' => 'Z',
+ 'doc' => 'download an uncompressed (.tar) file',
+ ),
+ ),
+ 'doc' => '...
+Download package tarballs. The files will be named as suggested by the
+server, for example if you download the DB package and the latest stable
+version of DB is 1.6.5, the downloaded file will be DB-1.6.5.tgz.',
+ ),
+ 'clear-cache' => array(
+ 'summary' => 'Clear Web Services Cache',
+ 'function' => 'doClearCache',
+ 'shortcut' => 'cc',
+ 'options' => array(),
+ 'doc' => '
+Clear the REST cache. See also the cache_ttl configuration
+parameter.
+',
+ ),
+ );
+
+ /**
+ * PEAR_Command_Remote constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ function _checkChannelForStatus($channel, $chan)
+ {
+ if (PEAR::isError($chan)) {
+ $this->raiseError($chan);
+ }
+ if (!is_a($chan, 'PEAR_ChannelFile')) {
+ return $this->raiseError('Internal corruption error: invalid channel "' .
+ $channel . '"');
+ }
+ $rest = new PEAR_REST($this->config);
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $mirror = $this->config->get('preferred_mirror', null,
+ $channel);
+ $a = $rest->downloadHttp('http://' . $channel .
+ '/channel.xml', $chan->lastModified());
+ PEAR::staticPopErrorHandling();
+ if (!PEAR::isError($a) && $a) {
+ $this->ui->outputData('WARNING: channel "' . $channel . '" has ' .
+ 'updated its protocols, use "' . PEAR_RUNTYPE . ' channel-update ' . $channel .
+ '" to update');
+ }
+ }
+
+ function doRemoteInfo($command, $options, $params)
+ {
+ if (sizeof($params) != 1) {
+ return $this->raiseError("$command expects one param: the remote package name");
+ }
+ $savechannel = $channel = $this->config->get('default_channel');
+ $reg = &$this->config->getRegistry();
+ $package = $params[0];
+ $parsed = $reg->parsePackageName($package, $channel);
+ if (PEAR::isError($parsed)) {
+ return $this->raiseError('Invalid package name "' . $package . '"');
+ }
+
+ $channel = $parsed['channel'];
+ $this->config->set('default_channel', $channel);
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($e = $this->_checkChannelForStatus($channel, $chan))) {
+ return $e;
+ }
+
+ $mirror = $this->config->get('preferred_mirror');
+ if ($chan->supportsREST($mirror) && $base = $chan->getBaseURL('REST1.0', $mirror)) {
+ $rest = &$this->config->getREST('1.0', array());
+ $info = $rest->packageInfo($base, $parsed['package'], $channel);
+ }
+
+ if (!isset($info)) {
+ return $this->raiseError('No supported protocol was found');
+ }
+
+ if (PEAR::isError($info)) {
+ $this->config->set('default_channel', $savechannel);
+ return $this->raiseError($info);
+ }
+
+ if (!isset($info['name'])) {
+ return $this->raiseError('No remote package "' . $package . '" was found');
+ }
+
+ $installed = $reg->packageInfo($info['name'], null, $channel);
+ $info['installed'] = $installed['version'] ? $installed['version'] : '- no -';
+ if (is_array($info['installed'])) {
+ $info['installed'] = $info['installed']['release'];
+ }
+
+ $this->ui->outputData($info, $command);
+ $this->config->set('default_channel', $savechannel);
+
+ return true;
+ }
+
+ function doRemoteList($command, $options, $params)
+ {
+ $savechannel = $channel = $this->config->get('default_channel');
+ $reg = &$this->config->getRegistry();
+ if (isset($options['channel'])) {
+ $channel = $options['channel'];
+ if (!$reg->channelExists($channel)) {
+ return $this->raiseError('Channel "' . $channel . '" does not exist');
+ }
+
+ $this->config->set('default_channel', $channel);
+ }
+
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($e = $this->_checkChannelForStatus($channel, $chan))) {
+ return $e;
+ }
+
+ $list_options = false;
+ if ($this->config->get('preferred_state') == 'stable') {
+ $list_options = true;
+ }
+
+ $available = array();
+ if ($chan->supportsREST($this->config->get('preferred_mirror')) &&
+ $base = $chan->getBaseURL('REST1.1', $this->config->get('preferred_mirror'))
+ ) {
+ // use faster list-all if available
+ $rest = &$this->config->getREST('1.1', array());
+ $available = $rest->listAll($base, $list_options, true, false, false, $chan->getName());
+ } elseif ($chan->supportsREST($this->config->get('preferred_mirror')) &&
+ $base = $chan->getBaseURL('REST1.0', $this->config->get('preferred_mirror'))) {
+ $rest = &$this->config->getREST('1.0', array());
+ $available = $rest->listAll($base, $list_options, true, false, false, $chan->getName());
+ }
+
+ if (PEAR::isError($available)) {
+ $this->config->set('default_channel', $savechannel);
+ return $this->raiseError($available);
+ }
+
+ $i = $j = 0;
+ $data = array(
+ 'caption' => 'Channel ' . $channel . ' Available packages:',
+ 'border' => true,
+ 'headline' => array('Package', 'Version'),
+ 'channel' => $channel
+ );
+
+ if (count($available) == 0) {
+ $data = '(no packages available yet)';
+ } else {
+ foreach ($available as $name => $info) {
+ $version = (isset($info['stable']) && $info['stable']) ? $info['stable'] : '-n/a-';
+ $data['data'][] = array($name, $version);
+ }
+ }
+ $this->ui->outputData($data, $command);
+ $this->config->set('default_channel', $savechannel);
+ return true;
+ }
+
+ function doListAll($command, $options, $params)
+ {
+ $savechannel = $channel = $this->config->get('default_channel');
+ $reg = &$this->config->getRegistry();
+ if (isset($options['channel'])) {
+ $channel = $options['channel'];
+ if (!$reg->channelExists($channel)) {
+ return $this->raiseError("Channel \"$channel\" does not exist");
+ }
+
+ $this->config->set('default_channel', $channel);
+ }
+
+ $list_options = false;
+ if ($this->config->get('preferred_state') == 'stable') {
+ $list_options = true;
+ }
+
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($e = $this->_checkChannelForStatus($channel, $chan))) {
+ return $e;
+ }
+
+ if ($chan->supportsREST($this->config->get('preferred_mirror')) &&
+ $base = $chan->getBaseURL('REST1.1', $this->config->get('preferred_mirror'))) {
+ // use faster list-all if available
+ $rest = &$this->config->getREST('1.1', array());
+ $available = $rest->listAll($base, $list_options, false, false, false, $chan->getName());
+ } elseif ($chan->supportsREST($this->config->get('preferred_mirror')) &&
+ $base = $chan->getBaseURL('REST1.0', $this->config->get('preferred_mirror'))) {
+ $rest = &$this->config->getREST('1.0', array());
+ $available = $rest->listAll($base, $list_options, false, false, false, $chan->getName());
+ }
+
+ if (PEAR::isError($available)) {
+ $this->config->set('default_channel', $savechannel);
+ return $this->raiseError('The package list could not be fetched from the remote server. Please try again. (Debug info: "' . $available->getMessage() . '")');
+ }
+
+ $data = array(
+ 'caption' => 'All packages [Channel ' . $channel . ']:',
+ 'border' => true,
+ 'headline' => array('Package', 'Latest', 'Local'),
+ 'channel' => $channel,
+ );
+
+ if (isset($options['channelinfo'])) {
+ // add full channelinfo
+ $data['caption'] = 'Channel ' . $channel . ' All packages:';
+ $data['headline'] = array('Channel', 'Package', 'Latest', 'Local',
+ 'Description', 'Dependencies');
+ }
+ $local_pkgs = $reg->listPackages($channel);
+
+ foreach ($available as $name => $info) {
+ $installed = $reg->packageInfo($name, null, $channel);
+ if (is_array($installed['version'])) {
+ $installed['version'] = $installed['version']['release'];
+ }
+ $desc = $info['summary'];
+ if (isset($params[$name])) {
+ $desc .= "\n\n".$info['description'];
+ }
+ if (isset($options['mode']))
+ {
+ if ($options['mode'] == 'installed' && !isset($installed['version'])) {
+ continue;
+ }
+ if ($options['mode'] == 'notinstalled' && isset($installed['version'])) {
+ continue;
+ }
+ if ($options['mode'] == 'upgrades'
+ && (!isset($installed['version']) || version_compare($installed['version'],
+ $info['stable'], '>='))) {
+ continue;
+ }
+ }
+ $pos = array_search(strtolower($name), $local_pkgs);
+ if ($pos !== false) {
+ unset($local_pkgs[$pos]);
+ }
+
+ if (isset($info['stable']) && !$info['stable']) {
+ $info['stable'] = null;
+ }
+
+ if (isset($options['channelinfo'])) {
+ // add full channelinfo
+ if ($info['stable'] === $info['unstable']) {
+ $state = $info['state'];
+ } else {
+ $state = 'stable';
+ }
+ $latest = $info['stable'].' ('.$state.')';
+ $local = '';
+ if (isset($installed['version'])) {
+ $inst_state = $reg->packageInfo($name, 'release_state', $channel);
+ $local = $installed['version'].' ('.$inst_state.')';
+ }
+
+ $packageinfo = array(
+ $channel,
+ $name,
+ $latest,
+ $local,
+ isset($desc) ? $desc : null,
+ isset($info['deps']) ? $info['deps'] : null,
+ );
+ } else {
+ $packageinfo = array(
+ $reg->channelAlias($channel) . '/' . $name,
+ isset($info['stable']) ? $info['stable'] : null,
+ isset($installed['version']) ? $installed['version'] : null,
+ isset($desc) ? $desc : null,
+ isset($info['deps']) ? $info['deps'] : null,
+ );
+ }
+ $data['data'][$info['category']][] = $packageinfo;
+ }
+
+ if (isset($options['mode']) && in_array($options['mode'], array('notinstalled', 'upgrades'))) {
+ $this->config->set('default_channel', $savechannel);
+ $this->ui->outputData($data, $command);
+ return true;
+ }
+
+ foreach ($local_pkgs as $name) {
+ $info = &$reg->getPackage($name, $channel);
+ $data['data']['Local'][] = array(
+ $reg->channelAlias($channel) . '/' . $info->getPackage(),
+ '',
+ $info->getVersion(),
+ $info->getSummary(),
+ $info->getDeps()
+ );
+ }
+
+ $this->config->set('default_channel', $savechannel);
+ $this->ui->outputData($data, $command);
+ return true;
+ }
+
+ function doSearch($command, $options, $params)
+ {
+ if ((!isset($params[0]) || empty($params[0]))
+ && (!isset($params[1]) || empty($params[1])))
+ {
+ return $this->raiseError('no valid search string supplied');
+ }
+
+ $channelinfo = isset($options['channelinfo']);
+ $reg = &$this->config->getRegistry();
+ if (isset($options['allchannels'])) {
+ // search all channels
+ unset($options['allchannels']);
+ $channels = $reg->getChannels();
+ $errors = array();
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ foreach ($channels as $channel) {
+ if ($channel->getName() != '__uri') {
+ $options['channel'] = $channel->getName();
+ $ret = $this->doSearch($command, $options, $params);
+ if (PEAR::isError($ret)) {
+ $errors[] = $ret;
+ }
+ }
+ }
+
+ PEAR::staticPopErrorHandling();
+ if (count($errors) !== 0) {
+ // for now, only give first error
+ return PEAR::raiseError($errors[0]);
+ }
+
+ return true;
+ }
+
+ $savechannel = $channel = $this->config->get('default_channel');
+ $package = strtolower($params[0]);
+ $summary = isset($params[1]) ? $params[1] : false;
+ if (isset($options['channel'])) {
+ $reg = &$this->config->getRegistry();
+ $channel = $options['channel'];
+ if (!$reg->channelExists($channel)) {
+ return $this->raiseError('Channel "' . $channel . '" does not exist');
+ }
+
+ $this->config->set('default_channel', $channel);
+ }
+
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($e = $this->_checkChannelForStatus($channel, $chan))) {
+ return $e;
+ }
+
+ if ($chan->supportsREST($this->config->get('preferred_mirror')) &&
+ $base = $chan->getBaseURL('REST1.0', $this->config->get('preferred_mirror'))) {
+ $rest = &$this->config->getREST('1.0', array());
+ $available = $rest->listAll($base, false, false, $package, $summary, $chan->getName());
+ }
+
+ if (PEAR::isError($available)) {
+ $this->config->set('default_channel', $savechannel);
+ return $this->raiseError($available);
+ }
+
+ if (!$available && !$channelinfo) {
+ // clean exit when not found, no error !
+ $data = 'no packages found that match pattern "' . $package . '", for channel '.$channel.'.';
+ $this->ui->outputData($data);
+ $this->config->set('default_channel', $channel);
+ return true;
+ }
+
+ if ($channelinfo) {
+ $data = array(
+ 'caption' => 'Matched packages, channel ' . $channel . ':',
+ 'border' => true,
+ 'headline' => array('Channel', 'Package', 'Stable/(Latest)', 'Local'),
+ 'channel' => $channel
+ );
+ } else {
+ $data = array(
+ 'caption' => 'Matched packages, channel ' . $channel . ':',
+ 'border' => true,
+ 'headline' => array('Package', 'Stable/(Latest)', 'Local'),
+ 'channel' => $channel
+ );
+ }
+
+ if (!$available && $channelinfo) {
+ unset($data['headline']);
+ $data['data'] = 'No packages found that match pattern "' . $package . '".';
+ $available = array();
+ }
+
+ foreach ($available as $name => $info) {
+ $installed = $reg->packageInfo($name, null, $channel);
+ $desc = $info['summary'];
+ if (isset($params[$name]))
+ $desc .= "\n\n".$info['description'];
+
+ if (!isset($info['stable']) || !$info['stable']) {
+ $version_remote = 'none';
+ } else {
+ if ($info['unstable']) {
+ $version_remote = $info['unstable'];
+ } else {
+ $version_remote = $info['stable'];
+ }
+ $version_remote .= ' ('.$info['state'].')';
+ }
+ $version = is_array($installed['version']) ? $installed['version']['release'] :
+ $installed['version'];
+ if ($channelinfo) {
+ $packageinfo = array(
+ $channel,
+ $name,
+ $version_remote,
+ $version,
+ $desc,
+ );
+ } else {
+ $packageinfo = array(
+ $name,
+ $version_remote,
+ $version,
+ $desc,
+ );
+ }
+ $data['data'][$info['category']][] = $packageinfo;
+ }
+
+ $this->ui->outputData($data, $command);
+ $this->config->set('default_channel', $channel);
+ return true;
+ }
+
+ function &getDownloader($options)
+ {
+ if (!class_exists('PEAR_Downloader')) {
+ require_once 'PEAR/Downloader.php';
+ }
+ $a = new PEAR_Downloader($this->ui, $options, $this->config);
+ return $a;
+ }
+
+ function doDownload($command, $options, $params)
+ {
+ // make certain that dependencies are ignored
+ $options['downloadonly'] = 1;
+
+ // eliminate error messages for preferred_state-related errors
+ /* TODO: Should be an option, but until now download does respect
+ prefered state */
+ /* $options['ignorepreferred_state'] = 1; */
+ // eliminate error messages for preferred_state-related errors
+
+ $downloader = &$this->getDownloader($options);
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $e = $downloader->setDownloadDir(getcwd());
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($e)) {
+ return $this->raiseError('Current directory is not writeable, cannot download');
+ }
+
+ $errors = array();
+ $downloaded = array();
+ $err = $downloader->download($params);
+ if (PEAR::isError($err)) {
+ return $err;
+ }
+
+ $errors = $downloader->getErrorMsgs();
+ if (count($errors)) {
+ foreach ($errors as $error) {
+ if ($error !== null) {
+ $this->ui->outputData($error);
+ }
+ }
+
+ return $this->raiseError("$command failed");
+ }
+
+ $downloaded = $downloader->getDownloadedPackages();
+ foreach ($downloaded as $pkg) {
+ $this->ui->outputData("File $pkg[file] downloaded", $command);
+ }
+
+ return true;
+ }
+
+ function downloadCallback($msg, $params = null)
+ {
+ if ($msg == 'done') {
+ $this->bytes_downloaded = $params;
+ }
+ }
+
+ function doListUpgrades($command, $options, $params)
+ {
+ require_once 'PEAR/Common.php';
+ if (isset($params[0]) && !is_array(PEAR_Common::betterStates($params[0]))) {
+ return $this->raiseError($params[0] . ' is not a valid state (stable/beta/alpha/devel/etc.) try "pear help list-upgrades"');
+ }
+
+ $savechannel = $channel = $this->config->get('default_channel');
+ $reg = &$this->config->getRegistry();
+ foreach ($reg->listChannels() as $channel) {
+ $inst = array_flip($reg->listPackages($channel));
+ if (!count($inst)) {
+ continue;
+ }
+
+ if ($channel == '__uri') {
+ continue;
+ }
+
+ $this->config->set('default_channel', $channel);
+ $state = empty($params[0]) ? $this->config->get('preferred_state') : $params[0];
+
+ $caption = $channel . ' Available Upgrades';
+ $chan = $reg->getChannel($channel);
+ if (PEAR::isError($e = $this->_checkChannelForStatus($channel, $chan))) {
+ return $e;
+ }
+
+ $latest = array();
+ $base2 = false;
+ $preferred_mirror = $this->config->get('preferred_mirror');
+ if ($chan->supportsREST($preferred_mirror) &&
+ (
+ ($base2 = $chan->getBaseURL('REST1.3', $preferred_mirror))
+ || ($base = $chan->getBaseURL('REST1.0', $preferred_mirror))
+ )
+
+ ) {
+ if ($base2) {
+ $rest = &$this->config->getREST('1.3', array());
+ $base = $base2;
+ } else {
+ $rest = &$this->config->getREST('1.0', array());
+ }
+
+ if (empty($state) || $state == 'any') {
+ $state = false;
+ } else {
+ $caption .= ' (' . implode(', ', PEAR_Common::betterStates($state, true)) . ')';
+ }
+
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ $latest = $rest->listLatestUpgrades($base, $state, $inst, $channel, $reg);
+ PEAR::staticPopErrorHandling();
+ }
+
+ if (PEAR::isError($latest)) {
+ $this->ui->outputData($latest->getMessage());
+ continue;
+ }
+
+ $caption .= ':';
+ if (PEAR::isError($latest)) {
+ $this->config->set('default_channel', $savechannel);
+ return $latest;
+ }
+
+ $data = array(
+ 'caption' => $caption,
+ 'border' => 1,
+ 'headline' => array('Channel', 'Package', 'Local', 'Remote', 'Size'),
+ 'channel' => $channel
+ );
+
+ foreach ((array)$latest as $pkg => $info) {
+ $package = strtolower($pkg);
+ if (!isset($inst[$package])) {
+ // skip packages we don't have installed
+ continue;
+ }
+
+ extract($info);
+ $inst_version = $reg->packageInfo($package, 'version', $channel);
+ $inst_state = $reg->packageInfo($package, 'release_state', $channel);
+ if (version_compare("$version", "$inst_version", "le")) {
+ // installed version is up-to-date
+ continue;
+ }
+
+ if ($filesize >= 20480) {
+ $filesize += 1024 - ($filesize % 1024);
+ $fs = sprintf("%dkB", $filesize / 1024);
+ } elseif ($filesize > 0) {
+ $filesize += 103 - ($filesize % 103);
+ $fs = sprintf("%.1fkB", $filesize / 1024.0);
+ } else {
+ $fs = " -"; // XXX center instead
+ }
+
+ $data['data'][] = array($channel, $pkg, "$inst_version ($inst_state)", "$version ($state)", $fs);
+ }
+
+ if (isset($options['channelinfo'])) {
+ if (empty($data['data'])) {
+ unset($data['headline']);
+ if (count($inst) == 0) {
+ $data['data'] = '(no packages installed)';
+ } else {
+ $data['data'] = '(no upgrades available)';
+ }
+ }
+ $this->ui->outputData($data, $command);
+ } else {
+ if (empty($data['data'])) {
+ $this->ui->outputData('Channel ' . $channel . ': No upgrades available');
+ } else {
+ $this->ui->outputData($data, $command);
+ }
+ }
+ }
+
+ $this->config->set('default_channel', $savechannel);
+ return true;
+ }
+
+ function doClearCache($command, $options, $params)
+ {
+ $cache_dir = $this->config->get('cache_dir');
+ $verbose = $this->config->get('verbose');
+ $output = '';
+ if (!file_exists($cache_dir) || !is_dir($cache_dir)) {
+ return $this->raiseError("$cache_dir does not exist or is not a directory");
+ }
+
+ if (!($dp = @opendir($cache_dir))) {
+ return $this->raiseError("opendir($cache_dir) failed: $php_errormsg");
+ }
+
+ if ($verbose >= 1) {
+ $output .= "reading directory $cache_dir\n";
+ }
+
+ $num = 0;
+ while ($ent = readdir($dp)) {
+ if (preg_match('/rest.cache(file|id)\\z/', $ent)) {
+ $path = $cache_dir . DIRECTORY_SEPARATOR . $ent;
+ if (file_exists($path)) {
+ $ok = @unlink($path);
+ } else {
+ $ok = false;
+ $php_errormsg = '';
+ }
+
+ if ($ok) {
+ if ($verbose >= 2) {
+ $output .= "deleted $path\n";
+ }
+ $num++;
+ } elseif ($verbose >= 1) {
+ $output .= "failed to delete $path $php_errormsg\n";
+ }
+ }
+ }
+
+ closedir($dp);
+ if ($verbose >= 1) {
+ $output .= "$num cache entries cleared\n";
+ }
+
+ $this->ui->outputData(rtrim($output), $command);
+ return $num;
+ }
+}
+ PEAR-1.10.1/PEAR/Command/Test.xml 0000644 0001750 0000144 00000003151 12610427352 015442 0 ustar cweiske users
+
+ Run Regression Tests
+ doRunTests
+ rt
+
+
+ r
+ Run tests in child directories, recursively. 4 dirs deep maximum
+
+
+ i
+ actual string of settings to pass to php in format " -d setting=blah"
+ SETTINGS
+
+
+ l
+ Log test runs/results as they are run
+
+
+ q
+ Only display detail for failed tests
+
+
+ s
+ Display simple output for all tests
+
+
+ p
+ Treat parameters as installed packages from which to run tests
+
+
+ u
+ Search parameters for AllTests.php, and use that to run phpunit-based tests
+If none is found, all .phpt tests will be tried instead.
+
+
+ t
+ Output run-tests.log in TAP-compliant format
+
+
+ c
+ CGI php executable (needed for tests with POST/GET section)
+ PHPCGI
+
+
+ x
+ Generate a code coverage report (requires Xdebug 2.0.0+)
+
+
+ [testfile|dir ...]
+Run regression tests with PHP's regression testing script (run-tests.php).
+
+ PEAR-1.10.1/PEAR/Command/Test.php 0000644 0001750 0000144 00000027547 12610427352 015450 0 ustar cweiske users
+ * @author Martin Jansen
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+
+/**
+ * base class
+ */
+require_once 'PEAR/Command/Common.php';
+
+/**
+ * PEAR commands for login/logout
+ *
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Martin Jansen
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+
+class PEAR_Command_Test extends PEAR_Command_Common
+{
+ var $commands = array(
+ 'run-tests' => array(
+ 'summary' => 'Run Regression Tests',
+ 'function' => 'doRunTests',
+ 'shortcut' => 'rt',
+ 'options' => array(
+ 'recur' => array(
+ 'shortopt' => 'r',
+ 'doc' => 'Run tests in child directories, recursively. 4 dirs deep maximum',
+ ),
+ 'ini' => array(
+ 'shortopt' => 'i',
+ 'doc' => 'actual string of settings to pass to php in format " -d setting=blah"',
+ 'arg' => 'SETTINGS'
+ ),
+ 'realtimelog' => array(
+ 'shortopt' => 'l',
+ 'doc' => 'Log test runs/results as they are run',
+ ),
+ 'quiet' => array(
+ 'shortopt' => 'q',
+ 'doc' => 'Only display detail for failed tests',
+ ),
+ 'simple' => array(
+ 'shortopt' => 's',
+ 'doc' => 'Display simple output for all tests',
+ ),
+ 'package' => array(
+ 'shortopt' => 'p',
+ 'doc' => 'Treat parameters as installed packages from which to run tests',
+ ),
+ 'phpunit' => array(
+ 'shortopt' => 'u',
+ 'doc' => 'Search parameters for AllTests.php, and use that to run phpunit-based tests
+If none is found, all .phpt tests will be tried instead.',
+ ),
+ 'tapoutput' => array(
+ 'shortopt' => 't',
+ 'doc' => 'Output run-tests.log in TAP-compliant format',
+ ),
+ 'cgi' => array(
+ 'shortopt' => 'c',
+ 'doc' => 'CGI php executable (needed for tests with POST/GET section)',
+ 'arg' => 'PHPCGI',
+ ),
+ 'coverage' => array(
+ 'shortopt' => 'x',
+ 'doc' => 'Generate a code coverage report (requires Xdebug 2.0.0+)',
+ ),
+ 'showdiff' => array(
+ 'shortopt' => 'd',
+ 'doc' => 'Output diff on test failure',
+ ),
+ ),
+ 'doc' => '[testfile|dir ...]
+Run regression tests with PHP\'s regression testing script (run-tests.php).',
+ ),
+ );
+
+ var $output;
+
+ /**
+ * PEAR_Command_Test constructor.
+ *
+ * @access public
+ */
+ function __construct(&$ui, &$config)
+ {
+ parent::__construct($ui, $config);
+ }
+
+ function doRunTests($command, $options, $params)
+ {
+ if (isset($options['phpunit']) && isset($options['tapoutput'])) {
+ return $this->raiseError('ERROR: cannot use both --phpunit and --tapoutput at the same time');
+ }
+
+ require_once 'PEAR/Common.php';
+ require_once 'System.php';
+ $log = new PEAR_Common;
+ $log->ui = &$this->ui; // slightly hacky, but it will work
+ $tests = array();
+ $depth = isset($options['recur']) ? 14 : 1;
+
+ if (!count($params)) {
+ $params[] = '.';
+ }
+
+ if (isset($options['package'])) {
+ $oldparams = $params;
+ $params = array();
+ $reg = &$this->config->getRegistry();
+ foreach ($oldparams as $param) {
+ $pname = $reg->parsePackageName($param, $this->config->get('default_channel'));
+ if (PEAR::isError($pname)) {
+ return $this->raiseError($pname);
+ }
+
+ $package = &$reg->getPackage($pname['package'], $pname['channel']);
+ if (!$package) {
+ return PEAR::raiseError('Unknown package "' .
+ $reg->parsedPackageNameToString($pname) . '"');
+ }
+
+ $filelist = $package->getFilelist();
+ foreach ($filelist as $name => $atts) {
+ if (isset($atts['role']) && $atts['role'] != 'test') {
+ continue;
+ }
+
+ if (isset($options['phpunit']) && preg_match('/AllTests\.php\\z/i', $name)) {
+ $params[] = $atts['installed_as'];
+ continue;
+ } elseif (!preg_match('/\.phpt\\z/', $name)) {
+ continue;
+ }
+ $params[] = $atts['installed_as'];
+ }
+ }
+ }
+
+ foreach ($params as $p) {
+ if (is_dir($p)) {
+ if (isset($options['phpunit'])) {
+ $dir = System::find(array($p, '-type', 'f',
+ '-maxdepth', $depth,
+ '-name', 'AllTests.php'));
+ if (count($dir)) {
+ foreach ($dir as $p) {
+ $p = realpath($p);
+ if (!count($tests) ||
+ (count($tests) && strlen($p) < strlen($tests[0]))) {
+ // this is in a higher-level directory, use this one instead.
+ $tests = array($p);
+ }
+ }
+ }
+ continue;
+ }
+
+ $args = array($p, '-type', 'f', '-name', '*.phpt');
+ } else {
+ if (isset($options['phpunit'])) {
+ if (preg_match('/AllTests\.php\\z/i', $p)) {
+ $p = realpath($p);
+ if (!count($tests) ||
+ (count($tests) && strlen($p) < strlen($tests[0]))) {
+ // this is in a higher-level directory, use this one instead.
+ $tests = array($p);
+ }
+ }
+ continue;
+ }
+
+ if (file_exists($p) && preg_match('/\.phpt$/', $p)) {
+ $tests[] = $p;
+ continue;
+ }
+
+ if (!preg_match('/\.phpt\\z/', $p)) {
+ $p .= '.phpt';
+ }
+
+ $args = array(dirname($p), '-type', 'f', '-name', $p);
+ }
+
+ if (!isset($options['recur'])) {
+ $args[] = '-maxdepth';
+ $args[] = 1;
+ }
+
+ $dir = System::find($args);
+ $tests = array_merge($tests, $dir);
+ }
+
+ $ini_settings = '';
+ if (isset($options['ini'])) {
+ $ini_settings .= $options['ini'];
+ }
+
+ if (isset($_ENV['TEST_PHP_INCLUDE_PATH'])) {
+ $ini_settings .= " -d include_path={$_ENV['TEST_PHP_INCLUDE_PATH']}";
+ }
+
+ if ($ini_settings) {
+ $this->ui->outputData('Using INI settings: "' . $ini_settings . '"');
+ }
+
+ $skipped = $passed = $failed = array();
+ $tests_count = count($tests);
+ $this->ui->outputData('Running ' . $tests_count . ' tests', $command);
+ $start = time();
+ if (isset($options['realtimelog']) && file_exists('run-tests.log')) {
+ unlink('run-tests.log');
+ }
+
+ if (isset($options['tapoutput'])) {
+ $tap = '1..' . $tests_count . "\n";
+ }
+
+ require_once 'PEAR/RunTest.php';
+ $run = new PEAR_RunTest($log, $options);
+ $run->tests_count = $tests_count;
+
+ if (isset($options['coverage']) && extension_loaded('xdebug')){
+ $run->xdebug_loaded = true;
+ } else {
+ $run->xdebug_loaded = false;
+ }
+
+ $j = $i = 1;
+ foreach ($tests as $t) {
+ if (isset($options['realtimelog'])) {
+ $fp = @fopen('run-tests.log', 'a');
+ if ($fp) {
+ fwrite($fp, "Running test [$i / $tests_count] $t...");
+ fclose($fp);
+ }
+ }
+ PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
+ if (isset($options['phpunit'])) {
+ $result = $run->runPHPUnit($t, $ini_settings);
+ } else {
+ $result = $run->run($t, $ini_settings, $j);
+ }
+ PEAR::staticPopErrorHandling();
+ if (PEAR::isError($result)) {
+ $this->ui->log($result->getMessage());
+ continue;
+ }
+
+ if (isset($options['tapoutput'])) {
+ $tap .= $result[0] . ' ' . $i . $result[1] . "\n";
+ continue;
+ }
+
+ if (isset($options['realtimelog'])) {
+ $fp = @fopen('run-tests.log', 'a');
+ if ($fp) {
+ fwrite($fp, "$result\n");
+ fclose($fp);
+ }
+ }
+
+ if ($result == 'FAILED') {
+ $failed[] = $t;
+ }
+ if ($result == 'PASSED') {
+ $passed[] = $t;
+ }
+ if ($result == 'SKIPPED') {
+ $skipped[] = $t;
+ }
+
+ $j++;
+ }
+
+ $total = date('i:s', time() - $start);
+ if (isset($options['tapoutput'])) {
+ $fp = @fopen('run-tests.log', 'w');
+ if ($fp) {
+ fwrite($fp, $tap, strlen($tap));
+ fclose($fp);
+ $this->ui->outputData('wrote TAP-format log to "' .realpath('run-tests.log') .
+ '"', $command);
+ }
+ } else {
+ if (count($failed)) {
+ $output = "TOTAL TIME: $total\n";
+ $output .= count($passed) . " PASSED TESTS\n";
+ $output .= count($skipped) . " SKIPPED TESTS\n";
+ $output .= count($failed) . " FAILED TESTS:\n";
+ foreach ($failed as $failure) {
+ $output .= $failure . "\n";
+ }
+
+ $mode = isset($options['realtimelog']) ? 'a' : 'w';
+ $fp = @fopen('run-tests.log', $mode);
+
+ if ($fp) {
+ fwrite($fp, $output, strlen($output));
+ fclose($fp);
+ $this->ui->outputData('wrote log to "' . realpath('run-tests.log') . '"', $command);
+ }
+ } elseif (file_exists('run-tests.log') && !is_dir('run-tests.log')) {
+ @unlink('run-tests.log');
+ }
+ }
+ $this->ui->outputData('TOTAL TIME: ' . $total);
+ $this->ui->outputData(count($passed) . ' PASSED TESTS', $command);
+ $this->ui->outputData(count($skipped) . ' SKIPPED TESTS', $command);
+ if (count($failed)) {
+ $this->ui->outputData(count($failed) . ' FAILED TESTS:', $command);
+ foreach ($failed as $failure) {
+ $this->ui->outputData($failure, $command);
+ }
+ }
+
+ if (count($failed) == 0) {
+ return true;
+ }
+ return $this->raiseError('Some tests failed');
+ }
+}
+ PEAR-1.10.1/PEAR/Downloader/Package.php 0000644 0001750 0000144 00000224604 12610427352 016575 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * Error code when parameter initialization fails because no releases
+ * exist within preferred_state, but releases do exist
+ */
+define('PEAR_DOWNLOADER_PACKAGE_STATE', -1003);
+/**
+ * Error code when parameter initialization fails because no releases
+ * exist that will work with the existing PHP version
+ */
+define('PEAR_DOWNLOADER_PACKAGE_PHPVERSION', -1004);
+
+/**
+ * Coordinates download parameters and manages their dependencies
+ * prior to downloading them.
+ *
+ * Input can come from three sources:
+ *
+ * - local files (archives or package.xml)
+ * - remote files (downloadable urls)
+ * - abstract package names
+ *
+ * The first two elements are handled cleanly by PEAR_PackageFile, but the third requires
+ * accessing pearweb's xml-rpc interface to determine necessary dependencies, and the
+ * format returned of dependencies is slightly different from that used in package.xml.
+ *
+ * This class hides the differences between these elements, and makes automatic
+ * dependency resolution a piece of cake. It also manages conflicts when
+ * two classes depend on incompatible dependencies, or differing versions of the same
+ * package dependency. In addition, download will not be attempted if the php version is
+ * not supported, PEAR installer version is not supported, or non-PECL extensions are not
+ * installed.
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Downloader_Package
+{
+ /**
+ * @var PEAR_Downloader
+ */
+ var $_downloader;
+ /**
+ * @var PEAR_Config
+ */
+ var $_config;
+ /**
+ * @var PEAR_Registry
+ */
+ var $_registry;
+ /**
+ * Used to implement packagingroot properly
+ * @var PEAR_Registry
+ */
+ var $_installRegistry;
+ /**
+ * @var PEAR_PackageFile_v1|PEAR_PackageFile|v2
+ */
+ var $_packagefile;
+ /**
+ * @var array
+ */
+ var $_parsedname;
+ /**
+ * @var array
+ */
+ var $_downloadURL;
+ /**
+ * @var array
+ */
+ var $_downloadDeps = array();
+ /**
+ * @var boolean
+ */
+ var $_valid = false;
+ /**
+ * @var boolean
+ */
+ var $_analyzed = false;
+ /**
+ * if this or a parent package was invoked with Package-state, this is set to the
+ * state variable.
+ *
+ * This allows temporary reassignment of preferred_state for a parent package and all of
+ * its dependencies.
+ * @var string|false
+ */
+ var $_explicitState = false;
+ /**
+ * If this package is invoked with Package#group, this variable will be true
+ */
+ var $_explicitGroup = false;
+ /**
+ * Package type local|url
+ * @var string
+ */
+ var $_type;
+ /**
+ * Contents of package.xml, if downloaded from a remote channel
+ * @var string|false
+ * @access private
+ */
+ var $_rawpackagefile;
+ /**
+ * @var boolean
+ * @access private
+ */
+ var $_validated = false;
+
+ /**
+ * @param PEAR_Downloader
+ */
+ function __construct(&$downloader)
+ {
+ $this->_downloader = &$downloader;
+ $this->_config = &$this->_downloader->config;
+ $this->_registry = &$this->_config->getRegistry();
+ $options = $downloader->getOptions();
+ if (isset($options['packagingroot'])) {
+ $this->_config->setInstallRoot($options['packagingroot']);
+ $this->_installRegistry = &$this->_config->getRegistry();
+ $this->_config->setInstallRoot(false);
+ } else {
+ $this->_installRegistry = &$this->_registry;
+ }
+ $this->_valid = $this->_analyzed = false;
+ }
+
+ /**
+ * Parse the input and determine whether this is a local file, a remote uri, or an
+ * abstract package name.
+ *
+ * This is the heart of the PEAR_Downloader_Package(), and is used in
+ * {@link PEAR_Downloader::download()}
+ * @param string
+ * @return bool|PEAR_Error
+ */
+ function initialize($param)
+ {
+ $origErr = $this->_fromFile($param);
+ if ($this->_valid) {
+ return true;
+ }
+
+ $options = $this->_downloader->getOptions();
+ if (isset($options['offline'])) {
+ if (PEAR::isError($origErr) && !isset($options['soft'])) {
+ foreach ($origErr->getUserInfo() as $userInfo) {
+ if (isset($userInfo['message'])) {
+ $this->_downloader->log(0, $userInfo['message']);
+ }
+ }
+
+ $this->_downloader->log(0, $origErr->getMessage());
+ }
+
+ return PEAR::raiseError('Cannot download non-local package "' . $param . '"');
+ }
+
+ $err = $this->_fromUrl($param);
+ if (PEAR::isError($err) || !$this->_valid) {
+ if ($this->_type == 'url') {
+ if (PEAR::isError($err) && !isset($options['soft'])) {
+ $this->_downloader->log(0, $err->getMessage());
+ }
+
+ return PEAR::raiseError("Invalid or missing remote package file");
+ }
+
+ $err = $this->_fromString($param);
+ if (PEAR::isError($err) || !$this->_valid) {
+ if (PEAR::isError($err) && $err->getCode() == PEAR_DOWNLOADER_PACKAGE_STATE) {
+ return false; // instruct the downloader to silently skip
+ }
+
+ if (isset($this->_type) && $this->_type == 'local' && PEAR::isError($origErr)) {
+ if (is_array($origErr->getUserInfo())) {
+ foreach ($origErr->getUserInfo() as $err) {
+ if (is_array($err)) {
+ $err = $err['message'];
+ }
+
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $err);
+ }
+ }
+ }
+
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $origErr->getMessage());
+ }
+
+ if (is_array($param)) {
+ $param = $this->_registry->parsedPackageNameToString($param, true);
+ }
+
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(2, "Cannot initialize '$param', invalid or missing package file");
+ }
+
+ // Passing no message back - already logged above
+ return PEAR::raiseError();
+ }
+
+ if (PEAR::isError($err) && !isset($options['soft'])) {
+ $this->_downloader->log(0, $err->getMessage());
+ }
+
+ if (is_array($param)) {
+ $param = $this->_registry->parsedPackageNameToString($param, true);
+ }
+
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(2, "Cannot initialize '$param', invalid or missing package file");
+ }
+
+ // Passing no message back - already logged above
+ return PEAR::raiseError();
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Retrieve any non-local packages
+ * @return PEAR_PackageFile_v1|PEAR_PackageFile_v2|PEAR_Error
+ */
+ function &download()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile;
+ }
+
+ if (isset($this->_downloadURL['url'])) {
+ $this->_isvalid = false;
+ $info = $this->getParsedPackage();
+ foreach ($info as $i => $p) {
+ $info[$i] = strtolower($p);
+ }
+
+ $err = $this->_fromUrl($this->_downloadURL['url'],
+ $this->_registry->parsedPackageNameToString($this->_parsedname, true));
+ $newinfo = $this->getParsedPackage();
+ foreach ($newinfo as $i => $p) {
+ $newinfo[$i] = strtolower($p);
+ }
+
+ if ($info != $newinfo) {
+ do {
+ if ($info['channel'] == 'pecl.php.net' && $newinfo['channel'] == 'pear.php.net') {
+ $info['channel'] = 'pear.php.net';
+ if ($info == $newinfo) {
+ // skip the channel check if a pecl package says it's a PEAR package
+ break;
+ }
+ }
+ if ($info['channel'] == 'pear.php.net' && $newinfo['channel'] == 'pecl.php.net') {
+ $info['channel'] = 'pecl.php.net';
+ if ($info == $newinfo) {
+ // skip the channel check if a pecl package says it's a PEAR package
+ break;
+ }
+ }
+
+ return PEAR::raiseError('CRITICAL ERROR: We are ' .
+ $this->_registry->parsedPackageNameToString($info) . ', but the file ' .
+ 'downloaded claims to be ' .
+ $this->_registry->parsedPackageNameToString($this->getParsedPackage()));
+ } while (false);
+ }
+
+ if (PEAR::isError($err) || !$this->_valid) {
+ return $err;
+ }
+ }
+
+ $this->_type = 'local';
+ return $this->_packagefile;
+ }
+
+ function &getPackageFile()
+ {
+ return $this->_packagefile;
+ }
+
+ function &getDownloader()
+ {
+ return $this->_downloader;
+ }
+
+ function getType()
+ {
+ return $this->_type;
+ }
+
+ /**
+ * Like {@link initialize()}, but operates on a dependency
+ */
+ function fromDepURL($dep)
+ {
+ $this->_downloadURL = $dep;
+ if (isset($dep['uri'])) {
+ $options = $this->_downloader->getOptions();
+ if (!extension_loaded("zlib") || isset($options['nocompress'])) {
+ $ext = '.tar';
+ } else {
+ $ext = '.tgz';
+ }
+
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ $err = $this->_fromUrl($dep['uri'] . $ext);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($err)) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $err->getMessage());
+ }
+
+ return PEAR::raiseError('Invalid uri dependency "' . $dep['uri'] . $ext . '", ' .
+ 'cannot download');
+ }
+ } else {
+ $this->_parsedname =
+ array(
+ 'package' => $dep['info']->getPackage(),
+ 'channel' => $dep['info']->getChannel(),
+ 'version' => $dep['version']
+ );
+ if (!isset($dep['nodefault'])) {
+ $this->_parsedname['group'] = 'default'; // download the default dependency group
+ $this->_explicitGroup = false;
+ }
+
+ $this->_rawpackagefile = $dep['raw'];
+ }
+ }
+
+ function detectDependencies($params)
+ {
+ $options = $this->_downloader->getOptions();
+ if (isset($options['downloadonly'])) {
+ return;
+ }
+
+ if (isset($options['offline'])) {
+ $this->_downloader->log(3, 'Skipping dependency download check, --offline specified');
+ return;
+ }
+
+ $pname = $this->getParsedPackage();
+ if (!$pname) {
+ return;
+ }
+
+ $deps = $this->getDeps();
+ if (!$deps) {
+ return;
+ }
+
+ if (isset($deps['required'])) { // package.xml 2.0
+ return $this->_detect2($deps, $pname, $options, $params);
+ }
+
+ return $this->_detect1($deps, $pname, $options, $params);
+ }
+
+ function setValidated()
+ {
+ $this->_validated = true;
+ }
+
+ function alreadyValidated()
+ {
+ return $this->_validated;
+ }
+
+ /**
+ * Remove packages to be downloaded that are already installed
+ * @param array of PEAR_Downloader_Package objects
+ */
+ public static function removeInstalled(&$params)
+ {
+ if (!isset($params[0])) {
+ return;
+ }
+
+ $options = $params[0]->_downloader->getOptions();
+ if (!isset($options['downloadonly'])) {
+ foreach ($params as $i => $param) {
+ $package = $param->getPackage();
+ $channel = $param->getChannel();
+ // remove self if already installed with this version
+ // this does not need any pecl magic - we only remove exact matches
+ if ($param->_installRegistry->packageExists($package, $channel)) {
+ $packageVersion = $param->_installRegistry->packageInfo($package, 'version', $channel);
+ if (version_compare($packageVersion, $param->getVersion(), '==')) {
+ if (!isset($options['force']) && !isset($options['packagingroot'])) {
+ $info = $param->getParsedPackage();
+ unset($info['version']);
+ unset($info['state']);
+ if (!isset($options['soft'])) {
+ $param->_downloader->log(1, 'Skipping package "' .
+ $param->getShortName() .
+ '", already installed as version ' . $packageVersion);
+ }
+ $params[$i] = false;
+ }
+ } elseif (!isset($options['force']) && !isset($options['upgrade']) &&
+ !isset($options['soft']) && !isset($options['packagingroot'])) {
+ $info = $param->getParsedPackage();
+ $param->_downloader->log(1, 'Skipping package "' .
+ $param->getShortName() .
+ '", already installed as version ' . $packageVersion);
+ $params[$i] = false;
+ }
+ }
+ }
+ }
+
+ PEAR_Downloader_Package::removeDuplicates($params);
+ }
+
+ function _detect2($deps, $pname, $options, $params)
+ {
+ $this->_downloadDeps = array();
+ $groupnotfound = false;
+ foreach (array('package', 'subpackage') as $packagetype) {
+ // get required dependency group
+ if (isset($deps['required'][$packagetype])) {
+ if (isset($deps['required'][$packagetype][0])) {
+ foreach ($deps['required'][$packagetype] as $dep) {
+ if (isset($dep['conflicts'])) {
+ // skip any package that this package conflicts with
+ continue;
+ }
+ $ret = $this->_detect2Dep($dep, $pname, 'required', $params);
+ if (is_array($ret)) {
+ $this->_downloadDeps[] = $ret;
+ } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+ $this->_downloader->log(0, $ret->getMessage());
+ }
+ }
+ } else {
+ $dep = $deps['required'][$packagetype];
+ if (!isset($dep['conflicts'])) {
+ // skip any package that this package conflicts with
+ $ret = $this->_detect2Dep($dep, $pname, 'required', $params);
+ if (is_array($ret)) {
+ $this->_downloadDeps[] = $ret;
+ } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+ $this->_downloader->log(0, $ret->getMessage());
+ }
+ }
+ }
+ }
+
+ // get optional dependency group, if any
+ if (isset($deps['optional'][$packagetype])) {
+ $skipnames = array();
+ if (!isset($deps['optional'][$packagetype][0])) {
+ $deps['optional'][$packagetype] = array($deps['optional'][$packagetype]);
+ }
+
+ foreach ($deps['optional'][$packagetype] as $dep) {
+ $skip = false;
+ if (!isset($options['alldeps'])) {
+ $dep['package'] = $dep['name'];
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(3, 'Notice: package "' .
+ $this->_registry->parsedPackageNameToString($this->getParsedPackage(),
+ true) . '" optional dependency "' .
+ $this->_registry->parsedPackageNameToString(array('package' =>
+ $dep['name'], 'channel' => 'pear.php.net'), true) .
+ '" will not be automatically downloaded');
+ }
+ $skipnames[] = $this->_registry->parsedPackageNameToString($dep, true);
+ $skip = true;
+ unset($dep['package']);
+ }
+
+ $ret = $this->_detect2Dep($dep, $pname, 'optional', $params);
+ if (PEAR::isError($ret) && !isset($options['soft'])) {
+ $this->_downloader->log(0, $ret->getMessage());
+ }
+
+ if (!$ret) {
+ $dep['package'] = $dep['name'];
+ $skip = count($skipnames) ?
+ $skipnames[count($skipnames) - 1] : '';
+ if ($skip ==
+ $this->_registry->parsedPackageNameToString($dep, true)) {
+ array_pop($skipnames);
+ }
+ }
+
+ if (!$skip && is_array($ret)) {
+ $this->_downloadDeps[] = $ret;
+ }
+ }
+
+ if (count($skipnames)) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(1, 'Did not download optional dependencies: ' .
+ implode(', ', $skipnames) .
+ ', use --alldeps to download automatically');
+ }
+ }
+ }
+
+ // get requested dependency group, if any
+ $groupname = $this->getGroup();
+ $explicit = $this->_explicitGroup;
+ if (!$groupname) {
+ if (!$this->canDefault()) {
+ continue;
+ }
+
+ $groupname = 'default'; // try the default dependency group
+ }
+
+ if ($groupnotfound) {
+ continue;
+ }
+
+ if (isset($deps['group'])) {
+ if (isset($deps['group']['attribs'])) {
+ if (strtolower($deps['group']['attribs']['name']) == strtolower($groupname)) {
+ $group = $deps['group'];
+ } elseif ($explicit) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, 'Warning: package "' .
+ $this->_registry->parsedPackageNameToString($pname, true) .
+ '" has no dependency ' . 'group named "' . $groupname . '"');
+ }
+
+ $groupnotfound = true;
+ continue;
+ }
+ } else {
+ $found = false;
+ foreach ($deps['group'] as $group) {
+ if (strtolower($group['attribs']['name']) == strtolower($groupname)) {
+ $found = true;
+ break;
+ }
+ }
+
+ if (!$found) {
+ if ($explicit) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, 'Warning: package "' .
+ $this->_registry->parsedPackageNameToString($pname, true) .
+ '" has no dependency ' . 'group named "' . $groupname . '"');
+ }
+ }
+
+ $groupnotfound = true;
+ continue;
+ }
+ }
+ }
+
+ if (isset($group) && isset($group[$packagetype])) {
+ if (isset($group[$packagetype][0])) {
+ foreach ($group[$packagetype] as $dep) {
+ $ret = $this->_detect2Dep($dep, $pname, 'dependency group "' .
+ $group['attribs']['name'] . '"', $params);
+ if (is_array($ret)) {
+ $this->_downloadDeps[] = $ret;
+ } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+ $this->_downloader->log(0, $ret->getMessage());
+ }
+ }
+ } else {
+ $ret = $this->_detect2Dep($group[$packagetype], $pname,
+ 'dependency group "' .
+ $group['attribs']['name'] . '"', $params);
+ if (is_array($ret)) {
+ $this->_downloadDeps[] = $ret;
+ } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
+ $this->_downloader->log(0, $ret->getMessage());
+ }
+ }
+ }
+ }
+ }
+
+ function _detect2Dep($dep, $pname, $group, $params)
+ {
+ if (isset($dep['conflicts'])) {
+ return true;
+ }
+
+ $options = $this->_downloader->getOptions();
+ if (isset($dep['uri'])) {
+ return array('uri' => $dep['uri'], 'dep' => $dep);;
+ }
+
+ $testdep = $dep;
+ $testdep['package'] = $dep['name'];
+ if (PEAR_Downloader_Package::willDownload($testdep, $params)) {
+ $dep['package'] = $dep['name'];
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group .
+ ' dependency "' .
+ $this->_registry->parsedPackageNameToString($dep, true) .
+ '", will be installed');
+ }
+ return false;
+ }
+
+ $options = $this->_downloader->getOptions();
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ if ($this->_explicitState) {
+ $pname['state'] = $this->_explicitState;
+ }
+
+ $url = $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
+ if (PEAR::isError($url)) {
+ PEAR::popErrorHandling();
+ return $url;
+ }
+
+ $dep['package'] = $dep['name'];
+ $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params, $group == 'optional' &&
+ !isset($options['alldeps']), true);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($ret)) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $ret->getMessage());
+ }
+
+ return false;
+ }
+
+ // check to see if a dep is already installed and is the same or newer
+ if (!isset($dep['min']) && !isset($dep['max']) && !isset($dep['recommended'])) {
+ $oper = 'has';
+ } else {
+ $oper = 'gt';
+ }
+
+ // do not try to move this before getDepPackageDownloadURL
+ // we can't determine whether upgrade is necessary until we know what
+ // version would be downloaded
+ if (!isset($options['force']) && $this->isInstalled($ret, $oper)) {
+ $version = $this->_installRegistry->packageInfo($dep['name'], 'version', $dep['channel']);
+ $dep['package'] = $dep['name'];
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group .
+ ' dependency "' .
+ $this->_registry->parsedPackageNameToString($dep, true) .
+ '" version ' . $url['version'] . ', already installed as version ' .
+ $version);
+ }
+
+ return false;
+ }
+
+ if (isset($dep['nodefault'])) {
+ $ret['nodefault'] = true;
+ }
+
+ return $ret;
+ }
+
+ function _detect1($deps, $pname, $options, $params)
+ {
+ $this->_downloadDeps = array();
+ $skipnames = array();
+ foreach ($deps as $dep) {
+ $nodownload = false;
+ if (isset ($dep['type']) && $dep['type'] === 'pkg') {
+ $dep['channel'] = 'pear.php.net';
+ $dep['package'] = $dep['name'];
+ switch ($dep['rel']) {
+ case 'not' :
+ continue 2;
+ case 'ge' :
+ case 'eq' :
+ case 'gt' :
+ case 'has' :
+ $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
+ 'required' :
+ 'optional';
+ if (PEAR_Downloader_Package::willDownload($dep, $params)) {
+ $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group
+ . ' dependency "' .
+ $this->_registry->parsedPackageNameToString($dep, true) .
+ '", will be installed');
+ continue 2;
+ }
+ $fakedp = new PEAR_PackageFile_v1;
+ $fakedp->setPackage($dep['name']);
+ // skip internet check if we are not upgrading (bug #5810)
+ if (!isset($options['upgrade']) && $this->isInstalled(
+ $fakedp, $dep['rel'])) {
+ $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group
+ . ' dependency "' .
+ $this->_registry->parsedPackageNameToString($dep, true) .
+ '", is already installed');
+ continue 2;
+ }
+ }
+
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ if ($this->_explicitState) {
+ $pname['state'] = $this->_explicitState;
+ }
+
+ $url = $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
+ $chan = 'pear.php.net';
+ if (PEAR::isError($url)) {
+ // check to see if this is a pecl package that has jumped
+ // from pear.php.net to pecl.php.net channel
+ if (!class_exists('PEAR_Dependency2')) {
+ require_once 'PEAR/Dependency2.php';
+ }
+
+ $newdep = PEAR_Dependency2::normalizeDep($dep);
+ $newdep = $newdep[0];
+ $newdep['channel'] = 'pecl.php.net';
+ $chan = 'pecl.php.net';
+ $url = $this->_downloader->_getDepPackageDownloadUrl($newdep, $pname);
+ $obj = &$this->_installRegistry->getPackage($dep['name']);
+ if (PEAR::isError($url)) {
+ PEAR::popErrorHandling();
+ if ($obj !== null && $this->isInstalled($obj, $dep['rel'])) {
+ $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
+ 'required' :
+ 'optional';
+ $dep['package'] = $dep['name'];
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(3, $this->getShortName() .
+ ': Skipping ' . $group . ' dependency "' .
+ $this->_registry->parsedPackageNameToString($dep, true) .
+ '", already installed as version ' . $obj->getVersion());
+ }
+ $skip = count($skipnames) ?
+ $skipnames[count($skipnames) - 1] : '';
+ if ($skip ==
+ $this->_registry->parsedPackageNameToString($dep, true)) {
+ array_pop($skipnames);
+ }
+ continue;
+ } else {
+ if (isset($dep['optional']) && $dep['optional'] == 'yes') {
+ $this->_downloader->log(2, $this->getShortName() .
+ ': Skipping optional dependency "' .
+ $this->_registry->parsedPackageNameToString($dep, true) .
+ '", no releases exist');
+ continue;
+ } else {
+ return $url;
+ }
+ }
+ }
+ }
+
+ PEAR::popErrorHandling();
+ if (!isset($options['alldeps'])) {
+ if (isset($dep['optional']) && $dep['optional'] == 'yes') {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(3, 'Notice: package "' .
+ $this->getShortName() .
+ '" optional dependency "' .
+ $this->_registry->parsedPackageNameToString(
+ array('channel' => $chan, 'package' =>
+ $dep['name']), true) .
+ '" will not be automatically downloaded');
+ }
+ $skipnames[] = $this->_registry->parsedPackageNameToString(
+ array('channel' => $chan, 'package' =>
+ $dep['name']), true);
+ $nodownload = true;
+ }
+ }
+
+ if (!isset($options['alldeps']) && !isset($options['onlyreqdeps'])) {
+ if (!isset($dep['optional']) || $dep['optional'] == 'no') {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(3, 'Notice: package "' .
+ $this->getShortName() .
+ '" required dependency "' .
+ $this->_registry->parsedPackageNameToString(
+ array('channel' => $chan, 'package' =>
+ $dep['name']), true) .
+ '" will not be automatically downloaded');
+ }
+ $skipnames[] = $this->_registry->parsedPackageNameToString(
+ array('channel' => $chan, 'package' =>
+ $dep['name']), true);
+ $nodownload = true;
+ }
+ }
+
+ // check to see if a dep is already installed
+ // do not try to move this before getDepPackageDownloadURL
+ // we can't determine whether upgrade is necessary until we know what
+ // version would be downloaded
+ if (!isset($options['force']) && $this->isInstalled(
+ $url, $dep['rel'])) {
+ $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
+ 'required' :
+ 'optional';
+ $dep['package'] = $dep['name'];
+ if (isset($newdep)) {
+ $version = $this->_installRegistry->packageInfo($newdep['name'], 'version', $newdep['channel']);
+ } else {
+ $version = $this->_installRegistry->packageInfo($dep['name'], 'version');
+ }
+
+ $dep['version'] = $url['version'];
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group .
+ ' dependency "' .
+ $this->_registry->parsedPackageNameToString($dep, true) .
+ '", already installed as version ' . $version);
+ }
+
+ $skip = count($skipnames) ?
+ $skipnames[count($skipnames) - 1] : '';
+ if ($skip ==
+ $this->_registry->parsedPackageNameToString($dep, true)) {
+ array_pop($skipnames);
+ }
+
+ continue;
+ }
+
+ if ($nodownload) {
+ continue;
+ }
+
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ if (isset($newdep)) {
+ $dep = $newdep;
+ }
+
+ $dep['package'] = $dep['name'];
+ $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params,
+ isset($dep['optional']) && $dep['optional'] == 'yes' &&
+ !isset($options['alldeps']), true);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($ret)) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $ret->getMessage());
+ }
+ continue;
+ }
+
+ $this->_downloadDeps[] = $ret;
+ }
+ }
+
+ if (count($skipnames)) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(1, 'Did not download dependencies: ' .
+ implode(', ', $skipnames) .
+ ', use --alldeps or --onlyreqdeps to download automatically');
+ }
+ }
+ }
+
+ function setDownloadURL($pkg)
+ {
+ $this->_downloadURL = $pkg;
+ }
+
+ /**
+ * Set the package.xml object for this downloaded package
+ *
+ * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2 $pkg
+ */
+ function setPackageFile(&$pkg)
+ {
+ $this->_packagefile = &$pkg;
+ }
+
+ function getShortName()
+ {
+ return $this->_registry->parsedPackageNameToString(array('channel' => $this->getChannel(),
+ 'package' => $this->getPackage()), true);
+ }
+
+ function getParsedPackage()
+ {
+ if (isset($this->_packagefile) || isset($this->_parsedname)) {
+ return array('channel' => $this->getChannel(),
+ 'package' => $this->getPackage(),
+ 'version' => $this->getVersion());
+ }
+
+ return false;
+ }
+
+ function getDownloadURL()
+ {
+ return $this->_downloadURL;
+ }
+
+ function canDefault()
+ {
+ if (isset($this->_downloadURL) && isset($this->_downloadURL['nodefault'])) {
+ return false;
+ }
+
+ return true;
+ }
+
+ function getPackage()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->getPackage();
+ } elseif (isset($this->_downloadURL['info'])) {
+ return $this->_downloadURL['info']->getPackage();
+ }
+
+ return false;
+ }
+
+ /**
+ * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
+ */
+ function isSubpackage(&$pf)
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->isSubpackage($pf);
+ } elseif (isset($this->_downloadURL['info'])) {
+ return $this->_downloadURL['info']->isSubpackage($pf);
+ }
+
+ return false;
+ }
+
+ function getPackageType()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->getPackageType();
+ } elseif (isset($this->_downloadURL['info'])) {
+ return $this->_downloadURL['info']->getPackageType();
+ }
+
+ return false;
+ }
+
+ function isBundle()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->getPackageType() == 'bundle';
+ }
+
+ return false;
+ }
+
+ function getPackageXmlVersion()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->getPackagexmlVersion();
+ } elseif (isset($this->_downloadURL['info'])) {
+ return $this->_downloadURL['info']->getPackagexmlVersion();
+ }
+
+ return '1.0';
+ }
+
+ function getChannel()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->getChannel();
+ } elseif (isset($this->_downloadURL['info'])) {
+ return $this->_downloadURL['info']->getChannel();
+ }
+
+ return false;
+ }
+
+ function getURI()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->getURI();
+ } elseif (isset($this->_downloadURL['info'])) {
+ return $this->_downloadURL['info']->getURI();
+ }
+
+ return false;
+ }
+
+ function getVersion()
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->getVersion();
+ } elseif (isset($this->_downloadURL['version'])) {
+ return $this->_downloadURL['version'];
+ }
+
+ return false;
+ }
+
+ function isCompatible($pf)
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->isCompatible($pf);
+ } elseif (isset($this->_downloadURL['info'])) {
+ return $this->_downloadURL['info']->isCompatible($pf);
+ }
+
+ return true;
+ }
+
+ function setGroup($group)
+ {
+ $this->_parsedname['group'] = $group;
+ }
+
+ function getGroup()
+ {
+ if (isset($this->_parsedname['group'])) {
+ return $this->_parsedname['group'];
+ }
+
+ return '';
+ }
+
+ function isExtension($name)
+ {
+ if (isset($this->_packagefile)) {
+ return $this->_packagefile->isExtension($name);
+ } elseif (isset($this->_downloadURL['info'])) {
+ if ($this->_downloadURL['info']->getPackagexmlVersion() == '2.0') {
+ return $this->_downloadURL['info']->getProvidesExtension() == $name;
+ }
+
+ return false;
+ }
+
+ return false;
+ }
+
+ function getDeps()
+ {
+ if (isset($this->_packagefile)) {
+ $ver = $this->_packagefile->getPackagexmlVersion();
+ if (version_compare($ver, '2.0', '>=')) {
+ return $this->_packagefile->getDeps(true);
+ }
+
+ return $this->_packagefile->getDeps();
+ } elseif (isset($this->_downloadURL['info'])) {
+ $ver = $this->_downloadURL['info']->getPackagexmlVersion();
+ if (version_compare($ver, '2.0', '>=')) {
+ return $this->_downloadURL['info']->getDeps(true);
+ }
+
+ return $this->_downloadURL['info']->getDeps();
+ }
+
+ return array();
+ }
+
+ /**
+ * @param array Parsed array from {@link PEAR_Registry::parsePackageName()} or a dependency
+ * returned from getDepDownloadURL()
+ */
+ function isEqual($param)
+ {
+ if (is_object($param)) {
+ $channel = $param->getChannel();
+ $package = $param->getPackage();
+ if ($param->getURI()) {
+ $param = array(
+ 'channel' => $param->getChannel(),
+ 'package' => $param->getPackage(),
+ 'version' => $param->getVersion(),
+ 'uri' => $param->getURI(),
+ );
+ } else {
+ $param = array(
+ 'channel' => $param->getChannel(),
+ 'package' => $param->getPackage(),
+ 'version' => $param->getVersion(),
+ );
+ }
+ } else {
+ if (isset($param['uri'])) {
+ if ($this->getChannel() != '__uri') {
+ return false;
+ }
+ return $param['uri'] == $this->getURI();
+ }
+
+ $package = isset($param['package']) ? $param['package'] : $param['info']->getPackage();
+ $channel = isset($param['channel']) ? $param['channel'] : $param['info']->getChannel();
+ if (isset($param['rel'])) {
+ if (!class_exists('PEAR_Dependency2')) {
+ require_once 'PEAR/Dependency2.php';
+ }
+
+ $newdep = PEAR_Dependency2::normalizeDep($param);
+ $newdep = $newdep[0];
+ } elseif (isset($param['min'])) {
+ $newdep = $param;
+ }
+ }
+
+ if (isset($newdep)) {
+ if (!isset($newdep['min'])) {
+ $newdep['min'] = '0';
+ }
+
+ if (!isset($newdep['max'])) {
+ $newdep['max'] = '100000000000000000000';
+ }
+
+ // use magic to support pecl packages suddenly jumping to the pecl channel
+ // we need to support both dependency possibilities
+ if ($channel == 'pear.php.net' && $this->getChannel() == 'pecl.php.net') {
+ if ($package == $this->getPackage()) {
+ $channel = 'pecl.php.net';
+ }
+ }
+ if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') {
+ if ($package == $this->getPackage()) {
+ $channel = 'pear.php.net';
+ }
+ }
+
+ return (strtolower($package) == strtolower($this->getPackage()) &&
+ $channel == $this->getChannel() &&
+ version_compare($newdep['min'], $this->getVersion(), '<=') &&
+ version_compare($newdep['max'], $this->getVersion(), '>='));
+ }
+
+ // use magic to support pecl packages suddenly jumping to the pecl channel
+ if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') {
+ if (strtolower($package) == strtolower($this->getPackage())) {
+ $channel = 'pear.php.net';
+ }
+ }
+
+ if (isset($param['version'])) {
+ return (strtolower($package) == strtolower($this->getPackage()) &&
+ $channel == $this->getChannel() &&
+ $param['version'] == $this->getVersion());
+ }
+
+ return strtolower($package) == strtolower($this->getPackage()) &&
+ $channel == $this->getChannel();
+ }
+
+ function isInstalled($dep, $oper = '==')
+ {
+ if (!$dep) {
+ return false;
+ }
+
+ if ($oper != 'ge' && $oper != 'gt' && $oper != 'has' && $oper != '==') {
+ return false;
+ }
+
+ if (is_object($dep)) {
+ $package = $dep->getPackage();
+ $channel = $dep->getChannel();
+ if ($dep->getURI()) {
+ $dep = array(
+ 'uri' => $dep->getURI(),
+ 'version' => $dep->getVersion(),
+ );
+ } else {
+ $dep = array(
+ 'version' => $dep->getVersion(),
+ );
+ }
+ } else {
+ if (isset($dep['uri'])) {
+ $channel = '__uri';
+ $package = $dep['dep']['name'];
+ } else {
+ $channel = $dep['info']->getChannel();
+ $package = $dep['info']->getPackage();
+ }
+ }
+
+ $options = $this->_downloader->getOptions();
+ $test = $this->_installRegistry->packageExists($package, $channel);
+ if (!$test && $channel == 'pecl.php.net') {
+ // do magic to allow upgrading from old pecl packages to new ones
+ $test = $this->_installRegistry->packageExists($package, 'pear.php.net');
+ $channel = 'pear.php.net';
+ }
+
+ if ($test) {
+ if (isset($dep['uri'])) {
+ if ($this->_installRegistry->packageInfo($package, 'uri', '__uri') == $dep['uri']) {
+ return true;
+ }
+ }
+
+ if (isset($options['upgrade'])) {
+ $packageVersion = $this->_installRegistry->packageInfo($package, 'version', $channel);
+ if (version_compare($packageVersion, $dep['version'], '>=')) {
+ return true;
+ }
+
+ return false;
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Detect duplicate package names with differing versions
+ *
+ * If a user requests to install Date 1.4.6 and Date 1.4.7,
+ * for instance, this is a logic error. This method
+ * detects this situation.
+ *
+ * @param array $params array of PEAR_Downloader_Package objects
+ * @param array $errorparams empty array
+ * @return array array of stupid duplicated packages in PEAR_Downloader_Package obejcts
+ */
+ public static function detectStupidDuplicates($params, &$errorparams)
+ {
+ $existing = array();
+ foreach ($params as $i => $param) {
+ $package = $param->getPackage();
+ $channel = $param->getChannel();
+ $group = $param->getGroup();
+ if (!isset($existing[$channel . '/' . $package])) {
+ $existing[$channel . '/' . $package] = array();
+ }
+
+ if (!isset($existing[$channel . '/' . $package][$group])) {
+ $existing[$channel . '/' . $package][$group] = array();
+ }
+
+ $existing[$channel . '/' . $package][$group][] = $i;
+ }
+
+ $indices = array();
+ foreach ($existing as $package => $groups) {
+ foreach ($groups as $group => $dupes) {
+ if (count($dupes) > 1) {
+ $indices = $indices + $dupes;
+ }
+ }
+ }
+
+ $indices = array_unique($indices);
+ foreach ($indices as $index) {
+ $errorparams[] = $params[$index];
+ }
+
+ return count($errorparams);
+ }
+
+ /**
+ * @param array
+ * @param bool ignore install groups - for final removal of dupe packages
+ */
+ public static function removeDuplicates(&$params, $ignoreGroups = false)
+ {
+ $pnames = array();
+ foreach ($params as $i => $param) {
+ if (!$param) {
+ continue;
+ }
+
+ if ($param->getPackage()) {
+ $group = $ignoreGroups ? '' : $param->getGroup();
+ $pnames[$i] = $param->getChannel() . '/' .
+ $param->getPackage() . '-' . $param->getVersion() . '#' . $group;
+ }
+ }
+
+ $pnames = array_unique($pnames);
+ $unset = array_diff(array_keys($params), array_keys($pnames));
+ $testp = array_flip($pnames);
+ foreach ($params as $i => $param) {
+ if (!$param) {
+ $unset[] = $i;
+ continue;
+ }
+
+ if (!is_a($param, 'PEAR_Downloader_Package')) {
+ $unset[] = $i;
+ continue;
+ }
+
+ $group = $ignoreGroups ? '' : $param->getGroup();
+ if (!isset($testp[$param->getChannel() . '/' . $param->getPackage() . '-' .
+ $param->getVersion() . '#' . $group])) {
+ $unset[] = $i;
+ }
+ }
+
+ foreach ($unset as $i) {
+ unset($params[$i]);
+ }
+
+ $ret = array();
+ foreach ($params as $i => $param) {
+ $ret[] = &$params[$i];
+ }
+
+ $params = array();
+ foreach ($ret as $i => $param) {
+ $params[] = &$ret[$i];
+ }
+ }
+
+ function explicitState()
+ {
+ return $this->_explicitState;
+ }
+
+ function setExplicitState($s)
+ {
+ $this->_explicitState = $s;
+ }
+
+ /**
+ */
+ public static function mergeDependencies(&$params)
+ {
+ $bundles = $newparams = array();
+ foreach ($params as $i => $param) {
+ if (!$param->isBundle()) {
+ continue;
+ }
+
+ $bundles[] = $i;
+ $pf = &$param->getPackageFile();
+ $newdeps = array();
+ $contents = $pf->getBundledPackages();
+ if (!is_array($contents)) {
+ $contents = array($contents);
+ }
+
+ foreach ($contents as $file) {
+ $filecontents = $pf->getFileContents($file);
+ $dl = &$param->getDownloader();
+ $options = $dl->getOptions();
+ if (PEAR::isError($dir = $dl->getDownloadDir())) {
+ return $dir;
+ }
+
+ $fp = @fopen($dir . DIRECTORY_SEPARATOR . $file, 'wb');
+ if (!$fp) {
+ continue;
+ }
+
+ // FIXME do symlink check
+
+ fwrite($fp, $filecontents, strlen($filecontents));
+ fclose($fp);
+ if ($s = $params[$i]->explicitState()) {
+ $obj->setExplicitState($s);
+ }
+
+ $obj = new PEAR_Downloader_Package($params[$i]->getDownloader());
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ if (PEAR::isError($dir = $dl->getDownloadDir())) {
+ PEAR::popErrorHandling();
+ return $dir;
+ }
+ $a = $dir . DIRECTORY_SEPARATOR . $file;
+ $e = $obj->_fromFile($a);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($e)) {
+ if (!isset($options['soft'])) {
+ $dl->log(0, $e->getMessage());
+ }
+ continue;
+ }
+
+ if (!PEAR_Downloader_Package::willDownload($obj,
+ array_merge($params, $newparams)) && !$param->isInstalled($obj)) {
+ $newparams[] = $obj;
+ }
+ }
+ }
+
+ foreach ($bundles as $i) {
+ unset($params[$i]); // remove bundles - only their contents matter for installation
+ }
+
+ PEAR_Downloader_Package::removeDuplicates($params); // strip any unset indices
+ if (count($newparams)) { // add in bundled packages for install
+ foreach ($newparams as $i => $unused) {
+ $params[] = &$newparams[$i];
+ }
+ $newparams = array();
+ }
+
+ foreach ($params as $i => $param) {
+ $newdeps = array();
+ foreach ($param->_downloadDeps as $dep) {
+ $merge = array_merge($params, $newparams);
+ if (!PEAR_Downloader_Package::willDownload($dep, $merge)
+ && !$param->isInstalled($dep)
+ ) {
+ $newdeps[] = $dep;
+ } else {
+ //var_dump($dep);
+ // detect versioning conflicts here
+ }
+ }
+
+ // convert the dependencies into PEAR_Downloader_Package objects for the next time around
+ $params[$i]->_downloadDeps = array();
+ foreach ($newdeps as $dep) {
+ $obj = new PEAR_Downloader_Package($params[$i]->getDownloader());
+ if ($s = $params[$i]->explicitState()) {
+ $obj->setExplicitState($s);
+ }
+
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ $e = $obj->fromDepURL($dep);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($e)) {
+ if (!isset($options['soft'])) {
+ $obj->_downloader->log(0, $e->getMessage());
+ }
+ continue;
+ }
+
+ $e = $obj->detectDependencies($params);
+ if (PEAR::isError($e)) {
+ if (!isset($options['soft'])) {
+ $obj->_downloader->log(0, $e->getMessage());
+ }
+ }
+
+ $newparams[] = $obj;
+ }
+ }
+
+ if (count($newparams)) {
+ foreach ($newparams as $i => $unused) {
+ $params[] = &$newparams[$i];
+ }
+ return true;
+ }
+
+ return false;
+ }
+
+
+ /**
+ */
+ public static function willDownload($param, $params)
+ {
+ if (!is_array($params)) {
+ return false;
+ }
+
+ foreach ($params as $obj) {
+ if ($obj->isEqual($param)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * For simpler unit-testing
+ * @param PEAR_Config
+ * @param int
+ * @param string
+ */
+ function &getPackagefileObject(&$c, $d)
+ {
+ $a = new PEAR_PackageFile($c, $d);
+ return $a;
+ }
+
+ /**
+ * This will retrieve from a local file if possible, and parse out
+ * a group name as well. The original parameter will be modified to reflect this.
+ * @param string|array can be a parsed package name as well
+ * @access private
+ */
+ function _fromFile(&$param)
+ {
+ $saveparam = $param;
+ if (is_string($param)) {
+ if (!@file_exists($param)) {
+ $test = explode('#', $param);
+ $group = array_pop($test);
+ if (@file_exists(implode('#', $test))) {
+ $this->setGroup($group);
+ $param = implode('#', $test);
+ $this->_explicitGroup = true;
+ }
+ }
+
+ if (@is_file($param)) {
+ $this->_type = 'local';
+ $options = $this->_downloader->getOptions();
+ $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->_debug);
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ $pf = &$pkg->fromAnyFile($param, PEAR_VALIDATE_INSTALLING);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($pf)) {
+ $this->_valid = false;
+ $param = $saveparam;
+ return $pf;
+ }
+ $this->_packagefile = &$pf;
+ if (!$this->getGroup()) {
+ $this->setGroup('default'); // install the default dependency group
+ }
+ return $this->_valid = true;
+ }
+ }
+ $param = $saveparam;
+ return $this->_valid = false;
+ }
+
+ function _fromUrl($param, $saveparam = '')
+ {
+ if (!is_array($param) && (preg_match('#^(http|https|ftp)://#', $param))) {
+ $options = $this->_downloader->getOptions();
+ $this->_type = 'url';
+ $callback = $this->_downloader->ui ?
+ array(&$this->_downloader, '_downloadCallback') : null;
+ $this->_downloader->pushErrorHandling(PEAR_ERROR_RETURN);
+ if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) {
+ $this->_downloader->popErrorHandling();
+ return $dir;
+ }
+
+ $this->_downloader->log(3, 'Downloading "' . $param . '"');
+ $file = $this->_downloader->downloadHttp($param, $this->_downloader->ui,
+ $dir, $callback, null, false, $this->getChannel());
+ $this->_downloader->popErrorHandling();
+ if (PEAR::isError($file)) {
+ if (!empty($saveparam)) {
+ $saveparam = ", cannot download \"$saveparam\"";
+ }
+ $err = PEAR::raiseError('Could not download from "' . $param .
+ '"' . $saveparam . ' (' . $file->getMessage() . ')');
+ return $err;
+ }
+
+ if ($this->_rawpackagefile) {
+ require_once 'Archive/Tar.php';
+ $tar = new Archive_Tar($file);
+ $packagexml = $tar->extractInString('package2.xml');
+ if (!$packagexml) {
+ $packagexml = $tar->extractInString('package.xml');
+ }
+
+ if (str_replace(array("\n", "\r"), array('',''), $packagexml) !=
+ str_replace(array("\n", "\r"), array('',''), $this->_rawpackagefile)) {
+ if ($this->getChannel() != 'pear.php.net') {
+ return PEAR::raiseError('CRITICAL ERROR: package.xml downloaded does ' .
+ 'not match value returned from xml-rpc');
+ }
+
+ // be more lax for the existing PEAR packages that have not-ok
+ // characters in their package.xml
+ $this->_downloader->log(0, 'CRITICAL WARNING: The "' .
+ $this->getPackage() . '" package has invalid characters in its ' .
+ 'package.xml. The next version of PEAR may not be able to install ' .
+ 'this package for security reasons. Please open a bug report at ' .
+ 'http://pear.php.net/package/' . $this->getPackage() . '/bugs');
+ }
+ }
+
+ // whew, download worked!
+ $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug);
+
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ $pf = &$pkg->fromAnyFile($file, PEAR_VALIDATE_INSTALLING);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($pf)) {
+ if (is_array($pf->getUserInfo())) {
+ foreach ($pf->getUserInfo() as $err) {
+ if (is_array($err)) {
+ $err = $err['message'];
+ }
+
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, "Validation Error: $err");
+ }
+ }
+ }
+
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $pf->getMessage());
+ }
+
+ ///FIXME need to pass back some error code that we can use to match with to cancel all further operations
+ /// At least stop all deps of this package from being installed
+ $out = $saveparam ? $saveparam : $param;
+ $err = PEAR::raiseError('Download of "' . $out . '" succeeded, but it is not a valid package archive');
+ $this->_valid = false;
+ return $err;
+ }
+
+ $this->_packagefile = &$pf;
+ $this->setGroup('default'); // install the default dependency group
+ return $this->_valid = true;
+ }
+
+ return $this->_valid = false;
+ }
+
+ /**
+ *
+ * @param string|array pass in an array of format
+ * array(
+ * 'package' => 'pname',
+ * ['channel' => 'channame',]
+ * ['version' => 'version',]
+ * ['state' => 'state',])
+ * or a string of format [channame/]pname[-version|-state]
+ */
+ function _fromString($param)
+ {
+ $options = $this->_downloader->getOptions();
+ $channel = $this->_config->get('default_channel');
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ $pname = $this->_registry->parsePackageName($param, $channel);
+ PEAR::popErrorHandling();
+ if (PEAR::isError($pname)) {
+ if ($pname->getCode() == 'invalid') {
+ $this->_valid = false;
+ return false;
+ }
+
+ if ($pname->getCode() == 'channel') {
+ $parsed = $pname->getUserInfo();
+ if ($this->_downloader->discover($parsed['channel'])) {
+ if ($this->_config->get('auto_discover')) {
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ $pname = $this->_registry->parsePackageName($param, $channel);
+ PEAR::popErrorHandling();
+ } else {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, 'Channel "' . $parsed['channel'] .
+ '" is not initialized, use ' .
+ '"pear channel-discover ' . $parsed['channel'] . '" to initialize' .
+ 'or pear config-set auto_discover 1');
+ }
+ }
+ }
+
+ if (PEAR::isError($pname)) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $pname->getMessage());
+ }
+
+ if (is_array($param)) {
+ $param = $this->_registry->parsedPackageNameToString($param);
+ }
+
+ $err = PEAR::raiseError('invalid package name/package file "' . $param . '"');
+ $this->_valid = false;
+ return $err;
+ }
+ } else {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(0, $pname->getMessage());
+ }
+
+ $err = PEAR::raiseError('invalid package name/package file "' . $param . '"');
+ $this->_valid = false;
+ return $err;
+ }
+ }
+
+ if (!isset($this->_type)) {
+ $this->_type = 'rest';
+ }
+
+ $this->_parsedname = $pname;
+ $this->_explicitState = isset($pname['state']) ? $pname['state'] : false;
+ $this->_explicitGroup = isset($pname['group']) ? true : false;
+
+ $info = $this->_downloader->_getPackageDownloadUrl($pname);
+ if (PEAR::isError($info)) {
+ if ($info->getCode() != -976 && $pname['channel'] == 'pear.php.net') {
+ // try pecl
+ $pname['channel'] = 'pecl.php.net';
+ if ($test = $this->_downloader->_getPackageDownloadUrl($pname)) {
+ if (!PEAR::isError($test)) {
+ $info = PEAR::raiseError($info->getMessage() . ' - package ' .
+ $this->_registry->parsedPackageNameToString($pname, true) .
+ ' can be installed with "pecl install ' . $pname['package'] .
+ '"');
+ } else {
+ $pname['channel'] = 'pear.php.net';
+ }
+ } else {
+ $pname['channel'] = 'pear.php.net';
+ }
+ }
+
+ return $info;
+ }
+
+ $this->_rawpackagefile = $info['raw'];
+ $ret = $this->_analyzeDownloadURL($info, $param, $pname);
+ if (PEAR::isError($ret)) {
+ return $ret;
+ }
+
+ if ($ret) {
+ $this->_downloadURL = $ret;
+ return $this->_valid = (bool) $ret;
+ }
+ }
+
+ /**
+ * @param array output of package.getDownloadURL
+ * @param string|array|object information for detecting packages to be downloaded, and
+ * for errors
+ * @param array name information of the package
+ * @param array|null packages to be downloaded
+ * @param bool is this an optional dependency?
+ * @param bool is this any kind of dependency?
+ * @access private
+ */
+ function _analyzeDownloadURL($info, $param, $pname, $params = null, $optional = false,
+ $isdependency = false)
+ {
+ if (!is_string($param) && PEAR_Downloader_Package::willDownload($param, $params)) {
+ return false;
+ }
+
+ if ($info === false) {
+ $saveparam = !is_string($param) ? ", cannot download \"$param\"" : '';
+
+ // no releases exist
+ return PEAR::raiseError('No releases for package "' .
+ $this->_registry->parsedPackageNameToString($pname, true) . '" exist' . $saveparam);
+ }
+
+ if (strtolower($info['info']->getChannel()) != strtolower($pname['channel'])) {
+ $err = false;
+ if ($pname['channel'] == 'pecl.php.net') {
+ if ($info['info']->getChannel() != 'pear.php.net') {
+ $err = true;
+ }
+ } elseif ($info['info']->getChannel() == 'pecl.php.net') {
+ if ($pname['channel'] != 'pear.php.net') {
+ $err = true;
+ }
+ } else {
+ $err = true;
+ }
+
+ if ($err) {
+ return PEAR::raiseError('SECURITY ERROR: package in channel "' . $pname['channel'] .
+ '" retrieved another channel\'s name for download! ("' .
+ $info['info']->getChannel() . '")');
+ }
+ }
+
+ $preferred_state = $this->_config->get('preferred_state');
+ if (!isset($info['url'])) {
+ $package_version = $this->_registry->packageInfo($info['info']->getPackage(),
+ 'version', $info['info']->getChannel());
+ if ($this->isInstalled($info)) {
+ if ($isdependency && version_compare($info['version'], $package_version, '<=')) {
+ // ignore bogus errors of "failed to download dependency"
+ // if it is already installed and the one that would be
+ // downloaded is older or the same version (Bug #7219)
+ return false;
+ }
+ }
+
+ if ($info['version'] === $package_version) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
+ '/' . $pname['package'] . '-' . $package_version. ', additionally the suggested version' .
+ ' (' . $package_version . ') is the same as the locally installed one.');
+ }
+
+ return false;
+ }
+
+ if (version_compare($info['version'], $package_version, '<=')) {
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
+ '/' . $pname['package'] . '-' . $package_version . ', additionally the suggested version' .
+ ' (' . $info['version'] . ') is a lower version than the locally installed one (' . $package_version . ').');
+ }
+
+ return false;
+ }
+
+ $instead = ', will instead download version ' . $info['version'] .
+ ', stability "' . $info['info']->getState() . '"';
+ // releases exist, but we failed to get any
+ if (isset($this->_downloader->_options['force'])) {
+ if (isset($pname['version'])) {
+ $vs = ', version "' . $pname['version'] . '"';
+ } elseif (isset($pname['state'])) {
+ $vs = ', stability "' . $pname['state'] . '"';
+ } elseif ($param == 'dependency') {
+ if (!class_exists('PEAR_Common')) {
+ require_once 'PEAR/Common.php';
+ }
+
+ if (!in_array($info['info']->getState(),
+ PEAR_Common::betterStates($preferred_state, true))) {
+ if ($optional) {
+ // don't spit out confusing error message
+ return $this->_downloader->_getPackageDownloadUrl(
+ array('package' => $pname['package'],
+ 'channel' => $pname['channel'],
+ 'version' => $info['version']));
+ }
+ $vs = ' within preferred state "' . $preferred_state .
+ '"';
+ } else {
+ if (!class_exists('PEAR_Dependency2')) {
+ require_once 'PEAR/Dependency2.php';
+ }
+
+ if ($optional) {
+ // don't spit out confusing error message
+ return $this->_downloader->_getPackageDownloadUrl(
+ array('package' => $pname['package'],
+ 'channel' => $pname['channel'],
+ 'version' => $info['version']));
+ }
+ $vs = PEAR_Dependency2::_getExtraString($pname);
+ $instead = '';
+ }
+ } else {
+ $vs = ' within preferred state "' . $preferred_state . '"';
+ }
+
+ if (!isset($options['soft'])) {
+ $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
+ '/' . $pname['package'] . $vs . $instead);
+ }
+
+ // download the latest release
+ return $this->_downloader->_getPackageDownloadUrl(
+ array('package' => $pname['package'],
+ 'channel' => $pname['channel'],
+ 'version' => $info['version']));
+ } else {
+ if (isset($info['php']) && $info['php']) {
+ $err = PEAR::raiseError('Failed to download ' .
+ $this->_registry->parsedPackageNameToString(
+ array('channel' => $pname['channel'],
+ 'package' => $pname['package']),
+ true) .
+ ', latest release is version ' . $info['php']['v'] .
+ ', but it requires PHP version "' .
+ $info['php']['m'] . '", use "' .
+ $this->_registry->parsedPackageNameToString(
+ array('channel' => $pname['channel'], 'package' => $pname['package'],
+ 'version' => $info['php']['v'])) . '" to install',
+ PEAR_DOWNLOADER_PACKAGE_PHPVERSION);
+ return $err;
+ }
+
+ // construct helpful error message
+ if (isset($pname['version'])) {
+ $vs = ', version "' . $pname['version'] . '"';
+ } elseif (isset($pname['state'])) {
+ $vs = ', stability "' . $pname['state'] . '"';
+ } elseif ($param == 'dependency') {
+ if (!class_exists('PEAR_Common')) {
+ require_once 'PEAR/Common.php';
+ }
+
+ if (!in_array($info['info']->getState(),
+ PEAR_Common::betterStates($preferred_state, true))) {
+ if ($optional) {
+ // don't spit out confusing error message, and don't die on
+ // optional dep failure!
+ return $this->_downloader->_getPackageDownloadUrl(
+ array('package' => $pname['package'],
+ 'channel' => $pname['channel'],
+ 'version' => $info['version']));
+ }
+ $vs = ' within preferred state "' . $preferred_state . '"';
+ } else {
+ if (!class_exists('PEAR_Dependency2')) {
+ require_once 'PEAR/Dependency2.php';
+ }
+
+ if ($optional) {
+ // don't spit out confusing error message, and don't die on
+ // optional dep failure!
+ return $this->_downloader->_getPackageDownloadUrl(
+ array('package' => $pname['package'],
+ 'channel' => $pname['channel'],
+ 'version' => $info['version']));
+ }
+ $vs = PEAR_Dependency2::_getExtraString($pname);
+ }
+ } else {
+ $vs = ' within preferred state "' . $this->_downloader->config->get('preferred_state') . '"';
+ }
+
+ $options = $this->_downloader->getOptions();
+ // this is only set by the "download-all" command
+ if (isset($options['ignorepreferred_state'])) {
+ $err = PEAR::raiseError(
+ 'Failed to download ' . $this->_registry->parsedPackageNameToString(
+ array('channel' => $pname['channel'], 'package' => $pname['package']),
+ true)
+ . $vs .
+ ', latest release is version ' . $info['version'] .
+ ', stability "' . $info['info']->getState() . '", use "' .
+ $this->_registry->parsedPackageNameToString(
+ array('channel' => $pname['channel'], 'package' => $pname['package'],
+ 'version' => $info['version'])) . '" to install',
+ PEAR_DOWNLOADER_PACKAGE_STATE);
+ return $err;
+ }
+
+ // Checks if the user has a package installed already and checks the release against
+ // the state against the installed package, this allows upgrades for packages
+ // with lower stability than the preferred_state
+ $stability = $this->_registry->packageInfo($pname['package'], 'stability', $pname['channel']);
+ if (!$this->isInstalled($info)
+ || !in_array($info['info']->getState(), PEAR_Common::betterStates($stability['release'], true))
+ ) {
+ $err = PEAR::raiseError(
+ 'Failed to download ' . $this->_registry->parsedPackageNameToString(
+ array('channel' => $pname['channel'], 'package' => $pname['package']),
+ true)
+ . $vs .
+ ', latest release is version ' . $info['version'] .
+ ', stability "' . $info['info']->getState() . '", use "' .
+ $this->_registry->parsedPackageNameToString(
+ array('channel' => $pname['channel'], 'package' => $pname['package'],
+ 'version' => $info['version'])) . '" to install');
+ return $err;
+ }
+ }
+ }
+
+ if (isset($info['deprecated']) && $info['deprecated']) {
+ $this->_downloader->log(0,
+ 'WARNING: "' .
+ $this->_registry->parsedPackageNameToString(
+ array('channel' => $info['info']->getChannel(),
+ 'package' => $info['info']->getPackage()), true) .
+ '" is deprecated in favor of "' .
+ $this->_registry->parsedPackageNameToString($info['deprecated'], true) .
+ '"');
+ }
+
+ return $info;
+ }
+}
+ PEAR-1.10.1/PEAR/Frontend/CLI.php 0000644 0001750 0000144 00000062114 12610427352 015326 0 ustar cweiske users
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 0.1
+ */
+/**
+ * base class
+ */
+require_once 'PEAR/Frontend.php';
+
+/**
+ * Command-line Frontend for the PEAR Installer
+ * @category pear
+ * @package PEAR
+ * @author Stig Bakken
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 0.1
+ */
+class PEAR_Frontend_CLI extends PEAR_Frontend
+{
+ /**
+ * What type of user interface this frontend is for.
+ * @var string
+ * @access public
+ */
+ var $type = 'CLI';
+ var $lp = ''; // line prefix
+
+ var $params = array();
+ var $term = array(
+ 'bold' => '',
+ 'normal' => '',
+ );
+
+ function __construct()
+ {
+ parent::__construct();
+ $term = getenv('TERM'); //(cox) $_ENV is empty for me in 4.1.1
+ if (function_exists('posix_isatty') && !posix_isatty(1)) {
+ // output is being redirected to a file or through a pipe
+ } elseif ($term) {
+ if (preg_match('/^(xterm|vt220|linux)/', $term)) {
+ $this->term['bold'] = sprintf("%c%c%c%c", 27, 91, 49, 109);
+ $this->term['normal'] = sprintf("%c%c%c", 27, 91, 109);
+ } elseif (preg_match('/^vt100/', $term)) {
+ $this->term['bold'] = sprintf("%c%c%c%c%c%c", 27, 91, 49, 109, 0, 0);
+ $this->term['normal'] = sprintf("%c%c%c%c%c", 27, 91, 109, 0, 0);
+ }
+ } elseif (OS_WINDOWS) {
+ // XXX add ANSI codes here
+ }
+ }
+
+ /**
+ * @param object PEAR_Error object
+ */
+ function displayError($e)
+ {
+ return $this->_displayLine($e->getMessage());
+ }
+
+ /**
+ * @param object PEAR_Error object
+ */
+ function displayFatalError($eobj)
+ {
+ $this->displayError($eobj);
+ if (class_exists('PEAR_Config')) {
+ $config = &PEAR_Config::singleton();
+ if ($config->get('verbose') > 5) {
+ if (function_exists('debug_print_backtrace')) {
+ debug_print_backtrace();
+ exit(1);
+ }
+
+ $raised = false;
+ foreach (debug_backtrace() as $i => $frame) {
+ if (!$raised) {
+ if (isset($frame['class'])
+ && strtolower($frame['class']) == 'pear'
+ && strtolower($frame['function']) == 'raiseerror'
+ ) {
+ $raised = true;
+ } else {
+ continue;
+ }
+ }
+
+ $frame['class'] = !isset($frame['class']) ? '' : $frame['class'];
+ $frame['type'] = !isset($frame['type']) ? '' : $frame['type'];
+ $frame['function'] = !isset($frame['function']) ? '' : $frame['function'];
+ $frame['line'] = !isset($frame['line']) ? '' : $frame['line'];
+ $this->_displayLine("#$i: $frame[class]$frame[type]$frame[function] $frame[line]");
+ }
+ }
+ }
+
+ exit(1);
+ }
+
+ /**
+ * Instruct the runInstallScript method to skip a paramgroup that matches the
+ * id value passed in.
+ *
+ * This method is useful for dynamically configuring which sections of a post-install script
+ * will be run based on the user's setup, which is very useful for making flexible
+ * post-install scripts without losing the cross-Frontend ability to retrieve user input
+ * @param string
+ */
+ function skipParamgroup($id)
+ {
+ $this->_skipSections[$id] = true;
+ }
+
+ function runPostinstallScripts(&$scripts)
+ {
+ foreach ($scripts as $i => $script) {
+ $this->runInstallScript($scripts[$i]->_params, $scripts[$i]->_obj);
+ }
+ }
+
+ /**
+ * @param array $xml contents of postinstallscript tag
+ * @param object $script post-installation script
+ * @param string install|upgrade
+ */
+ function runInstallScript($xml, &$script)
+ {
+ $this->_skipSections = array();
+ if (!is_array($xml) || !isset($xml['paramgroup'])) {
+ $script->run(array(), '_default');
+ return;
+ }
+
+ $completedPhases = array();
+ if (!isset($xml['paramgroup'][0])) {
+ $xml['paramgroup'] = array($xml['paramgroup']);
+ }
+
+ foreach ($xml['paramgroup'] as $group) {
+ if (isset($this->_skipSections[$group['id']])) {
+ // the post-install script chose to skip this section dynamically
+ continue;
+ }
+
+ if (isset($group['name'])) {
+ $paramname = explode('::', $group['name']);
+ if ($lastgroup['id'] != $paramname[0]) {
+ continue;
+ }
+
+ $group['name'] = $paramname[1];
+ if (!isset($answers)) {
+ return;
+ }
+
+ if (isset($answers[$group['name']])) {
+ switch ($group['conditiontype']) {
+ case '=' :
+ if ($answers[$group['name']] != $group['value']) {
+ continue 2;
+ }
+ break;
+ case '!=' :
+ if ($answers[$group['name']] == $group['value']) {
+ continue 2;
+ }
+ break;
+ case 'preg_match' :
+ if (!@preg_match('/' . $group['value'] . '/',
+ $answers[$group['name']])) {
+ continue 2;
+ }
+ break;
+ default :
+ return;
+ }
+ }
+ }
+
+ $lastgroup = $group;
+ if (isset($group['instructions'])) {
+ $this->_display($group['instructions']);
+ }
+
+ if (!isset($group['param'][0])) {
+ $group['param'] = array($group['param']);
+ }
+
+ if (isset($group['param'])) {
+ if (method_exists($script, 'postProcessPrompts')) {
+ $prompts = $script->postProcessPrompts($group['param'], $group['id']);
+ if (!is_array($prompts) || count($prompts) != count($group['param'])) {
+ $this->outputData('postinstall', 'Error: post-install script did not ' .
+ 'return proper post-processed prompts');
+ $prompts = $group['param'];
+ } else {
+ foreach ($prompts as $i => $var) {
+ if (!is_array($var) || !isset($var['prompt']) ||
+ !isset($var['name']) ||
+ ($var['name'] != $group['param'][$i]['name']) ||
+ ($var['type'] != $group['param'][$i]['type'])
+ ) {
+ $this->outputData('postinstall', 'Error: post-install script ' .
+ 'modified the variables or prompts, severe security risk. ' .
+ 'Will instead use the defaults from the package.xml');
+ $prompts = $group['param'];
+ }
+ }
+ }
+
+ $answers = $this->confirmDialog($prompts);
+ } else {
+ $answers = $this->confirmDialog($group['param']);
+ }
+ }
+
+ if ((isset($answers) && $answers) || !isset($group['param'])) {
+ if (!isset($answers)) {
+ $answers = array();
+ }
+
+ array_unshift($completedPhases, $group['id']);
+ if (!$script->run($answers, $group['id'])) {
+ $script->run($completedPhases, '_undoOnError');
+ return;
+ }
+ } else {
+ $script->run($completedPhases, '_undoOnError');
+ return;
+ }
+ }
+ }
+
+ /**
+ * Ask for user input, confirm the answers and continue until the user is satisfied
+ * @param array an array of arrays, format array('name' => 'paramname', 'prompt' =>
+ * 'text to display', 'type' => 'string'[, default => 'default value'])
+ * @return array
+ */
+ function confirmDialog($params)
+ {
+ $answers = $prompts = $types = array();
+ foreach ($params as $param) {
+ $prompts[$param['name']] = $param['prompt'];
+ $types[$param['name']] = $param['type'];
+ $answers[$param['name']] = isset($param['default']) ? $param['default'] : '';
+ }
+
+ $tried = false;
+ do {
+ if ($tried) {
+ $i = 1;
+ foreach ($answers as $var => $value) {
+ if (!strlen($value)) {
+ echo $this->bold("* Enter an answer for #" . $i . ": ({$prompts[$var]})\n");
+ }
+ $i++;
+ }
+ }
+
+ $answers = $this->userDialog('', $prompts, $types, $answers);
+ $tried = true;
+ } while (is_array($answers) && count(array_filter($answers)) != count($prompts));
+
+ return $answers;
+ }
+
+ function userDialog($command, $prompts, $types = array(), $defaults = array(), $screensize = 20)
+ {
+ if (!is_array($prompts)) {
+ return array();
+ }
+
+ $testprompts = array_keys($prompts);
+ $result = $defaults;
+
+ reset($prompts);
+ if (count($prompts) === 1) {
+ foreach ($prompts as $key => $prompt) {
+ $type = $types[$key];
+ $default = @$defaults[$key];
+ print "$prompt ";
+ if ($default) {
+ print "[$default] ";
+ }
+ print ": ";
+
+ $line = fgets(STDIN, 2048);
+ $result[$key] = ($default && trim($line) == '') ? $default : trim($line);
+ }
+
+ return $result;
+ }
+
+ $first_run = true;
+ while (true) {
+ $descLength = max(array_map('strlen', $prompts));
+ $descFormat = "%-{$descLength}s";
+ $last = count($prompts);
+
+ $i = 0;
+ foreach ($prompts as $n => $var) {
+ $res = isset($result[$n]) ? $result[$n] : null;
+ printf("%2d. $descFormat : %s\n", ++$i, $prompts[$n], $res);
+ }
+ print "\n1-$last, 'all', 'abort', or Enter to continue: ";
+
+ $tmp = trim(fgets(STDIN, 1024));
+ if (empty($tmp)) {
+ break;
+ }
+
+ if ($tmp == 'abort') {
+ return false;
+ }
+
+ if (isset($testprompts[(int)$tmp - 1])) {
+ $var = $testprompts[(int)$tmp - 1];
+ $desc = $prompts[$var];
+ $current = @$result[$var];
+ print "$desc [$current] : ";
+ $tmp = trim(fgets(STDIN, 1024));
+ if ($tmp !== '') {
+ $result[$var] = $tmp;
+ }
+ } elseif ($tmp == 'all') {
+ foreach ($prompts as $var => $desc) {
+ $current = $result[$var];
+ print "$desc [$current] : ";
+ $tmp = trim(fgets(STDIN, 1024));
+ if (trim($tmp) !== '') {
+ $result[$var] = trim($tmp);
+ }
+ }
+ }
+
+ $first_run = false;
+ }
+
+ return $result;
+ }
+
+ function userConfirm($prompt, $default = 'yes')
+ {
+ trigger_error("PEAR_Frontend_CLI::userConfirm not yet converted", E_USER_ERROR);
+ static $positives = array('y', 'yes', 'on', '1');
+ static $negatives = array('n', 'no', 'off', '0');
+ print "$this->lp$prompt [$default] : ";
+ $fp = fopen("php://stdin", "r");
+ $line = fgets($fp, 2048);
+ fclose($fp);
+ $answer = strtolower(trim($line));
+ if (empty($answer)) {
+ $answer = $default;
+ }
+ if (in_array($answer, $positives)) {
+ return true;
+ }
+ if (in_array($answer, $negatives)) {
+ return false;
+ }
+ if (in_array($default, $positives)) {
+ return true;
+ }
+ return false;
+ }
+
+ function outputData($data, $command = '_default')
+ {
+ switch ($command) {
+ case 'channel-info':
+ foreach ($data as $type => $section) {
+ if ($type == 'main') {
+ $section['data'] = array_values($section['data']);
+ }
+
+ $this->outputData($section);
+ }
+ break;
+ case 'install':
+ case 'upgrade':
+ case 'upgrade-all':
+ if (is_array($data) && isset($data['release_warnings'])) {
+ $this->_displayLine('');
+ $this->_startTable(array(
+ 'border' => false,
+ 'caption' => 'Release Warnings'
+ ));
+ $this->_tableRow(array($data['release_warnings']), null, array(1 => array('wrap' => 55)));
+ $this->_endTable();
+ $this->_displayLine('');
+ }
+
+ $this->_displayLine(is_array($data) ? $data['data'] : $data);
+ break;
+ case 'search':
+ $this->_startTable($data);
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'], array('bold' => true), array(1 => array('wrap' => 55)));
+ }
+
+ $packages = array();
+ foreach($data['data'] as $category) {
+ foreach($category as $name => $pkg) {
+ $packages[$pkg[0]] = $pkg;
+ }
+ }
+
+ $p = array_keys($packages);
+ natcasesort($p);
+ foreach ($p as $name) {
+ $this->_tableRow($packages[$name], null, array(1 => array('wrap' => 55)));
+ }
+
+ $this->_endTable();
+ break;
+ case 'list-all':
+ if (!isset($data['data'])) {
+ $this->_displayLine('No packages in channel');
+ break;
+ }
+
+ $this->_startTable($data);
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'], array('bold' => true), array(1 => array('wrap' => 55)));
+ }
+
+ $packages = array();
+ foreach($data['data'] as $category) {
+ foreach($category as $name => $pkg) {
+ $packages[$pkg[0]] = $pkg;
+ }
+ }
+
+ $p = array_keys($packages);
+ natcasesort($p);
+ foreach ($p as $name) {
+ $pkg = $packages[$name];
+ unset($pkg[4], $pkg[5]);
+ $this->_tableRow($pkg, null, array(1 => array('wrap' => 55)));
+ }
+
+ $this->_endTable();
+ break;
+ case 'config-show':
+ $data['border'] = false;
+ $opts = array(
+ 0 => array('wrap' => 30),
+ 1 => array('wrap' => 20),
+ 2 => array('wrap' => 35)
+ );
+
+ $this->_startTable($data);
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'], array('bold' => true), $opts);
+ }
+
+ foreach ($data['data'] as $group) {
+ foreach ($group as $value) {
+ if ($value[2] == '') {
+ $value[2] = "";
+ }
+
+ $this->_tableRow($value, null, $opts);
+ }
+ }
+
+ $this->_endTable();
+ break;
+ case 'remote-info':
+ $d = $data;
+ $data = array(
+ 'caption' => 'Package details:',
+ 'border' => false,
+ 'data' => array(
+ array("Latest", $data['stable']),
+ array("Installed", $data['installed']),
+ array("Package", $data['name']),
+ array("License", $data['license']),
+ array("Category", $data['category']),
+ array("Summary", $data['summary']),
+ array("Description", $data['description']),
+ ),
+ );
+
+ if (isset($d['deprecated']) && $d['deprecated']) {
+ $conf = &PEAR_Config::singleton();
+ $reg = $conf->getRegistry();
+ $name = $reg->parsedPackageNameToString($d['deprecated'], true);
+ $data['data'][] = array('Deprecated! use', $name);
+ }
+ default: {
+ if (is_array($data)) {
+ $this->_startTable($data);
+ $count = count($data['data'][0]);
+ if ($count == 2) {
+ $opts = array(0 => array('wrap' => 25),
+ 1 => array('wrap' => 48)
+ );
+ } elseif ($count == 3) {
+ $opts = array(0 => array('wrap' => 30),
+ 1 => array('wrap' => 20),
+ 2 => array('wrap' => 35)
+ );
+ } else {
+ $opts = null;
+ }
+ if (isset($data['headline']) && is_array($data['headline'])) {
+ $this->_tableRow($data['headline'],
+ array('bold' => true),
+ $opts);
+ }
+
+ if (is_array($data['data'])) {
+ foreach($data['data'] as $row) {
+ $this->_tableRow($row, null, $opts);
+ }
+ } else {
+ $this->_tableRow(array($data['data']), null, $opts);
+ }
+ $this->_endTable();
+ } else {
+ $this->_displayLine($data);
+ }
+ }
+ }
+ }
+
+ function log($text, $append_crlf = true)
+ {
+ if ($append_crlf) {
+ return $this->_displayLine($text);
+ }
+
+ return $this->_display($text);
+ }
+
+ function bold($text)
+ {
+ if (empty($this->term['bold'])) {
+ return strtoupper($text);
+ }
+
+ return $this->term['bold'] . $text . $this->term['normal'];
+ }
+
+ function _displayHeading($title)
+ {
+ print $this->lp.$this->bold($title)."\n";
+ print $this->lp.str_repeat("=", strlen($title))."\n";
+ }
+
+ function _startTable($params = array())
+ {
+ $params['table_data'] = array();
+ $params['widest'] = array(); // indexed by column
+ $params['highest'] = array(); // indexed by row
+ $params['ncols'] = 0;
+ $this->params = $params;
+ }
+
+ function _tableRow($columns, $rowparams = array(), $colparams = array())
+ {
+ $highest = 1;
+ for ($i = 0; $i < count($columns); $i++) {
+ $col = &$columns[$i];
+ if (isset($colparams[$i]) && !empty($colparams[$i]['wrap'])) {
+ $col = wordwrap($col, $colparams[$i]['wrap']);
+ }
+
+ if (strpos($col, "\n") !== false) {
+ $multiline = explode("\n", $col);
+ $w = 0;
+ foreach ($multiline as $n => $line) {
+ $len = strlen($line);
+ if ($len > $w) {
+ $w = $len;
+ }
+ }
+ $lines = count($multiline);
+ } else {
+ $w = strlen($col);
+ }
+
+ if (isset($this->params['widest'][$i])) {
+ if ($w > $this->params['widest'][$i]) {
+ $this->params['widest'][$i] = $w;
+ }
+ } else {
+ $this->params['widest'][$i] = $w;
+ }
+
+ $tmp = count_chars($columns[$i], 1);
+ // handle unix, mac and windows formats
+ $lines = (isset($tmp[10]) ? $tmp[10] : (isset($tmp[13]) ? $tmp[13] : 0)) + 1;
+ if ($lines > $highest) {
+ $highest = $lines;
+ }
+ }
+
+ if (count($columns) > $this->params['ncols']) {
+ $this->params['ncols'] = count($columns);
+ }
+
+ $new_row = array(
+ 'data' => $columns,
+ 'height' => $highest,
+ 'rowparams' => $rowparams,
+ 'colparams' => $colparams,
+ );
+ $this->params['table_data'][] = $new_row;
+ }
+
+ function _endTable()
+ {
+ extract($this->params);
+ if (!empty($caption)) {
+ $this->_displayHeading($caption);
+ }
+
+ if (count($table_data) === 0) {
+ return;
+ }
+
+ if (!isset($width)) {
+ $width = $widest;
+ } else {
+ for ($i = 0; $i < $ncols; $i++) {
+ if (!isset($width[$i])) {
+ $width[$i] = $widest[$i];
+ }
+ }
+ }
+
+ $border = false;
+ if (empty($border)) {
+ $cellstart = '';
+ $cellend = ' ';
+ $rowend = '';
+ $padrowend = false;
+ $borderline = '';
+ } else {
+ $cellstart = '| ';
+ $cellend = ' ';
+ $rowend = '|';
+ $padrowend = true;
+ $borderline = '+';
+ foreach ($width as $w) {
+ $borderline .= str_repeat('-', $w + strlen($cellstart) + strlen($cellend) - 1);
+ $borderline .= '+';
+ }
+ }
+
+ if ($borderline) {
+ $this->_displayLine($borderline);
+ }
+
+ for ($i = 0; $i < count($table_data); $i++) {
+ extract($table_data[$i]);
+ if (!is_array($rowparams)) {
+ $rowparams = array();
+ }
+
+ if (!is_array($colparams)) {
+ $colparams = array();
+ }
+
+ $rowlines = array();
+ if ($height > 1) {
+ for ($c = 0; $c < count($data); $c++) {
+ $rowlines[$c] = preg_split('/(\r?\n|\r)/', $data[$c]);
+ if (count($rowlines[$c]) < $height) {
+ $rowlines[$c] = array_pad($rowlines[$c], $height, '');
+ }
+ }
+ } else {
+ for ($c = 0; $c < count($data); $c++) {
+ $rowlines[$c] = array($data[$c]);
+ }
+ }
+
+ for ($r = 0; $r < $height; $r++) {
+ $rowtext = '';
+ for ($c = 0; $c < count($data); $c++) {
+ if (isset($colparams[$c])) {
+ $attribs = array_merge($rowparams, $colparams);
+ } else {
+ $attribs = $rowparams;
+ }
+
+ $w = isset($width[$c]) ? $width[$c] : 0;
+ //$cell = $data[$c];
+ $cell = $rowlines[$c][$r];
+ $l = strlen($cell);
+ if ($l > $w) {
+ $cell = substr($cell, 0, $w);
+ }
+
+ if (isset($attribs['bold'])) {
+ $cell = $this->bold($cell);
+ }
+
+ if ($l < $w) {
+ // not using str_pad here because we may
+ // add bold escape characters to $cell
+ $cell .= str_repeat(' ', $w - $l);
+ }
+
+ $rowtext .= $cellstart . $cell . $cellend;
+ }
+
+ if (!$border) {
+ $rowtext = rtrim($rowtext);
+ }
+
+ $rowtext .= $rowend;
+ $this->_displayLine($rowtext);
+ }
+ }
+
+ if ($borderline) {
+ $this->_displayLine($borderline);
+ }
+ }
+
+ function _displayLine($text)
+ {
+ print "$this->lp$text\n";
+ }
+
+ function _display($text)
+ {
+ print $text;
+ }
+}
+ PEAR-1.10.1/PEAR/Installer/Role/Common.php 0000644 0001750 0000144 00000014106 12610427352 017224 0 ustar cweiske users
+ * @copyright 1997-2006 The PHP Group
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+/**
+ * Base class for all installation roles.
+ *
+ * This class allows extensibility of file roles. Packages with complex
+ * customization can now provide custom file roles along with the possibility of
+ * adding configuration values to match.
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2006 The PHP Group
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Common
+{
+ /**
+ * @var PEAR_Config
+ * @access protected
+ */
+ var $config;
+
+ /**
+ * @param PEAR_Config
+ */
+ function __construct(&$config)
+ {
+ $this->config = $config;
+ }
+
+ /**
+ * Retrieve configuration information about a file role from its XML info
+ *
+ * @param string $role Role Classname, as in "PEAR_Installer_Role_Data"
+ * @return array
+ */
+ function getInfo($role)
+ {
+ if (empty($GLOBALS['_PEAR_INSTALLER_ROLES'][$role])) {
+ return PEAR::raiseError('Unknown Role class: "' . $role . '"');
+ }
+ return $GLOBALS['_PEAR_INSTALLER_ROLES'][$role];
+ }
+
+ /**
+ * This is called for each file to set up the directories and files
+ * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
+ * @param array attributes from the tag
+ * @param string file name
+ * @return array an array consisting of:
+ *
+ * 1 the original, pre-baseinstalldir installation directory
+ * 2 the final installation directory
+ * 3 the full path to the final location of the file
+ * 4 the location of the pre-installation file
+ */
+ function processInstallation($pkg, $atts, $file, $tmp_path, $layer = null)
+ {
+ $roleInfo = PEAR_Installer_Role_Common::getInfo('PEAR_Installer_Role_' .
+ ucfirst(str_replace('pear_installer_role_', '', strtolower(get_class($this)))));
+ if (PEAR::isError($roleInfo)) {
+ return $roleInfo;
+ }
+ if (!$roleInfo['locationconfig']) {
+ return false;
+ }
+ if ($roleInfo['honorsbaseinstall']) {
+ $dest_dir = $save_destdir = $this->config->get($roleInfo['locationconfig'], $layer,
+ $pkg->getChannel());
+ if (!empty($atts['baseinstalldir'])) {
+ $dest_dir .= DIRECTORY_SEPARATOR . $atts['baseinstalldir'];
+ }
+ } elseif ($roleInfo['unusualbaseinstall']) {
+ $dest_dir = $save_destdir = $this->config->get($roleInfo['locationconfig'],
+ $layer, $pkg->getChannel()) . DIRECTORY_SEPARATOR . $pkg->getPackage();
+ if (!empty($atts['baseinstalldir'])) {
+ $dest_dir .= DIRECTORY_SEPARATOR . $atts['baseinstalldir'];
+ }
+ } else {
+ $dest_dir = $save_destdir = $this->config->get($roleInfo['locationconfig'],
+ $layer, $pkg->getChannel()) . DIRECTORY_SEPARATOR . $pkg->getPackage();
+ }
+ if (dirname($file) != '.' && empty($atts['install-as'])) {
+ $dest_dir .= DIRECTORY_SEPARATOR . dirname($file);
+ }
+ if (empty($atts['install-as'])) {
+ $dest_file = $dest_dir . DIRECTORY_SEPARATOR . basename($file);
+ } else {
+ $dest_file = $dest_dir . DIRECTORY_SEPARATOR . $atts['install-as'];
+ }
+ $orig_file = $tmp_path . DIRECTORY_SEPARATOR . $file;
+
+ // Clean up the DIRECTORY_SEPARATOR mess
+ $ds2 = DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR;
+
+ list($dest_dir, $dest_file, $orig_file) = preg_replace(array('!\\\\+!', '!/!', "!$ds2+!"),
+ array(DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR,
+ DIRECTORY_SEPARATOR),
+ array($dest_dir, $dest_file, $orig_file));
+ return array($save_destdir, $dest_dir, $dest_file, $orig_file);
+ }
+
+ /**
+ * Get the name of the configuration variable that specifies the location of this file
+ * @return string|false
+ */
+ function getLocationConfig()
+ {
+ $roleInfo = PEAR_Installer_Role_Common::getInfo('PEAR_Installer_Role_' .
+ ucfirst(str_replace('pear_installer_role_', '', strtolower(get_class($this)))));
+ if (PEAR::isError($roleInfo)) {
+ return $roleInfo;
+ }
+ return $roleInfo['locationconfig'];
+ }
+
+ /**
+ * Do any unusual setup here
+ * @param PEAR_Installer
+ * @param PEAR_PackageFile_v2
+ * @param array file attributes
+ * @param string file name
+ */
+ function setup(&$installer, $pkg, $atts, $file)
+ {
+ }
+
+ function isExecutable()
+ {
+ $roleInfo = PEAR_Installer_Role_Common::getInfo('PEAR_Installer_Role_' .
+ ucfirst(str_replace('pear_installer_role_', '', strtolower(get_class($this)))));
+ if (PEAR::isError($roleInfo)) {
+ return $roleInfo;
+ }
+ return $roleInfo['executable'];
+ }
+
+ function isInstallable()
+ {
+ $roleInfo = PEAR_Installer_Role_Common::getInfo('PEAR_Installer_Role_' .
+ ucfirst(str_replace('pear_installer_role_', '', strtolower(get_class($this)))));
+ if (PEAR::isError($roleInfo)) {
+ return $roleInfo;
+ }
+ return $roleInfo['installable'];
+ }
+
+ function isExtension()
+ {
+ $roleInfo = PEAR_Installer_Role_Common::getInfo('PEAR_Installer_Role_' .
+ ucfirst(str_replace('pear_installer_role_', '', strtolower(get_class($this)))));
+ if (PEAR::isError($roleInfo)) {
+ return $roleInfo;
+ }
+ return $roleInfo['phpextension'];
+ }
+}
+?>
+ PEAR-1.10.1/PEAR/Installer/Role/Cfg.xml 0000644 0001750 0000144 00000000645 12610427352 016507 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ cfg_dir
+
+ 1
+
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Cfg.php 0000644 0001750 0000144 00000007576 12610427352 016510 0 ustar cweiske users
+ * @copyright 2007-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.7.0
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 2007-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.7.0
+ */
+class PEAR_Installer_Role_Cfg extends PEAR_Installer_Role_Common
+{
+ /**
+ * @var PEAR_Installer
+ */
+ var $installer;
+
+ /**
+ * the md5 of the original file
+ *
+ * @var unknown_type
+ */
+ var $md5 = null;
+
+ /**
+ * Do any unusual setup here
+ * @param PEAR_Installer
+ * @param PEAR_PackageFile_v2
+ * @param array file attributes
+ * @param string file name
+ */
+ function setup(&$installer, $pkg, $atts, $file)
+ {
+ $this->installer = &$installer;
+ $reg = &$this->installer->config->getRegistry();
+ $package = $reg->getPackage($pkg->getPackage(), $pkg->getChannel());
+ if ($package) {
+ $filelist = $package->getFilelist();
+ if (isset($filelist[$file]) && isset($filelist[$file]['md5sum'])) {
+ $this->md5 = $filelist[$file]['md5sum'];
+ }
+ }
+ }
+
+ function processInstallation($pkg, $atts, $file, $tmp_path, $layer = null)
+ {
+ $test = parent::processInstallation($pkg, $atts, $file, $tmp_path, $layer);
+ if (@file_exists($test[2]) && @file_exists($test[3])) {
+ $md5 = md5_file($test[2]);
+ // configuration has already been installed, check for mods
+ if ($md5 !== $this->md5 && $md5 !== md5_file($test[3])) {
+ // configuration has been modified, so save our version as
+ // configfile-version
+ $old = $test[2];
+ $test[2] .= '.new-' . $pkg->getVersion();
+ // backup original and re-install it
+ PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
+ $tmpcfg = $this->config->get('temp_dir');
+ $newloc = System::mkdir(array('-p', $tmpcfg));
+ if (!$newloc) {
+ // try temp_dir
+ $newloc = System::mktemp(array('-d'));
+ if (!$newloc || PEAR::isError($newloc)) {
+ PEAR::popErrorHandling();
+ return PEAR::raiseError('Could not save existing configuration file '.
+ $old . ', unable to install. Please set temp_dir ' .
+ 'configuration variable to a writeable location and try again');
+ }
+ } else {
+ $newloc = $tmpcfg;
+ }
+
+ $temp_file = $newloc . DIRECTORY_SEPARATOR . uniqid('savefile');
+ if (!@copy($old, $temp_file)) {
+ PEAR::popErrorHandling();
+ return PEAR::raiseError('Could not save existing configuration file '.
+ $old . ', unable to install. Please set temp_dir ' .
+ 'configuration variable to a writeable location and try again');
+ }
+
+ PEAR::popErrorHandling();
+ $this->installer->log(0, "WARNING: configuration file $old is being installed as $test[2], you should manually merge in changes to the existing configuration file");
+ $this->installer->addFileOperation('rename', array($temp_file, $old, false));
+ $this->installer->addFileOperation('delete', array($temp_file));
+ }
+ }
+
+ return $test;
+ }
+} PEAR-1.10.1/PEAR/Installer/Role/Data.xml 0000644 0001750 0000144 00000000622 12610427352 016654 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ data_dir
+
+
+
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Data.php 0000644 0001750 0000144 00000001416 12610427352 016645 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Data extends PEAR_Installer_Role_Common {}
+?> PEAR-1.10.1/PEAR/Installer/Role/Doc.xml 0000644 0001750 0000144 00000000621 12610427352 016507 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ doc_dir
+
+
+
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Doc.php 0000644 0001750 0000144 00000001414 12610427352 016477 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Doc extends PEAR_Installer_Role_Common {}
+?> PEAR-1.10.1/PEAR/Installer/Role/Ext.xml 0000644 0001750 0000144 00000000502 12610427352 016540 0 ustar cweiske users
+ extbin
+ zendextbin
+ 1
+ ext_dir
+ 1
+
+
+
+ 1
+
+ PEAR-1.10.1/PEAR/Installer/Role/Ext.php 0000644 0001750 0000144 00000001414 12610427352 016532 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Ext extends PEAR_Installer_Role_Common {}
+?> PEAR-1.10.1/PEAR/Installer/Role/Man.xml 0000644 0001750 0000144 00000000645 12610427352 016523 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ man_dir
+ 1
+
+
+
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Man.php 0000644 0001750 0000144 00000001444 12610427352 016510 0 ustar cweiske users
+ * @copyright 2011 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version SVN: $Id: $
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.10.0
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Hannes Magnusson
+ * @copyright 2011 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.10.0
+ */
+class PEAR_Installer_Role_Man extends PEAR_Installer_Role_Common {}
+?>
+ PEAR-1.10.1/PEAR/Installer/Role/Php.xml 0000644 0001750 0000144 00000000655 12610427352 016540 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ php_dir
+ 1
+
+ 1
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Php.php 0000644 0001750 0000144 00000001414 12610427352 016521 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Php extends PEAR_Installer_Role_Common {}
+?> PEAR-1.10.1/PEAR/Installer/Role/Script.xml 0000644 0001750 0000144 00000000660 12610427352 017251 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ bin_dir
+ 1
+
+
+ 1
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Script.php 0000644 0001750 0000144 00000001422 12610427352 017235 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Script extends PEAR_Installer_Role_Common {}
+?> PEAR-1.10.1/PEAR/Installer/Role/Src.xml 0000644 0001750 0000144 00000000442 12610427352 016532 0 ustar cweiske users
+ extsrc
+ zendextsrc
+ 1
+ temp_dir
+
+
+
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Src.php 0000644 0001750 0000144 00000001561 12610427352 016524 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Src extends PEAR_Installer_Role_Common
+{
+ function setup(&$installer, $pkg, $atts, $file)
+ {
+ $installer->source_files++;
+ }
+}
+?> PEAR-1.10.1/PEAR/Installer/Role/Test.xml 0000644 0001750 0000144 00000000622 12610427352 016722 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ test_dir
+
+
+
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Test.php 0000644 0001750 0000144 00000001416 12610427352 016713 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role_Test extends PEAR_Installer_Role_Common {}
+?> PEAR-1.10.1/PEAR/Installer/Role/Www.xml 0000644 0001750 0000144 00000000644 12610427352 016573 0 ustar cweiske users
+ php
+ extsrc
+ extbin
+ zendextsrc
+ zendextbin
+ 1
+ www_dir
+ 1
+
+
+
+
+
+ PEAR-1.10.1/PEAR/Installer/Role/Www.php 0000644 0001750 0000144 00000001410 12610427352 016552 0 ustar cweiske users
+ * @copyright 2007-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.7.0
+ */
+
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 2007-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.7.0
+ */
+class PEAR_Installer_Role_Www extends PEAR_Installer_Role_Common {}
+?> PEAR-1.10.1/PEAR/Installer/Role.php 0000644 0001750 0000144 00000017273 12610427352 016004 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+
+/**
+ * base class for installer roles
+ */
+require_once 'PEAR/Installer/Role/Common.php';
+require_once 'PEAR/XMLParser.php';
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_Installer_Role
+{
+ /**
+ * Set up any additional configuration variables that file roles require
+ *
+ * Never call this directly, it is called by the PEAR_Config constructor
+ * @param PEAR_Config
+ */
+ public static function initializeConfig(&$config)
+ {
+ if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
+ PEAR_Installer_Role::registerRoles();
+ }
+
+ foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'] as $class => $info) {
+ if (!$info['config_vars']) {
+ continue;
+ }
+
+ $config->_addConfigVars($class, $info['config_vars']);
+ }
+ }
+
+ /**
+ * @param PEAR_PackageFile_v2
+ * @param string role name
+ * @param PEAR_Config
+ * @return PEAR_Installer_Role_Common
+ */
+ public static function &factory($pkg, $role, &$config)
+ {
+ if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
+ PEAR_Installer_Role::registerRoles();
+ }
+
+ if (!in_array($role, PEAR_Installer_Role::getValidRoles($pkg->getPackageType()))) {
+ $a = false;
+ return $a;
+ }
+
+ $a = 'PEAR_Installer_Role_' . ucfirst($role);
+ if (!class_exists($a)) {
+ require_once str_replace('_', '/', $a) . '.php';
+ }
+
+ $b = new $a($config);
+ return $b;
+ }
+
+ /**
+ * Get a list of file roles that are valid for the particular release type.
+ *
+ * For instance, src files serve no purpose in regular php releases.
+ * @param string
+ * @param bool clear cache
+ * @return array
+ */
+ public static function getValidRoles($release, $clear = false)
+ {
+ if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
+ PEAR_Installer_Role::registerRoles();
+ }
+
+ static $ret = array();
+ if ($clear) {
+ $ret = array();
+ }
+
+ if (isset($ret[$release])) {
+ return $ret[$release];
+ }
+
+ $ret[$release] = array();
+ foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'] as $role => $okreleases) {
+ if (in_array($release, $okreleases['releasetypes'])) {
+ $ret[$release][] = strtolower(str_replace('PEAR_Installer_Role_', '', $role));
+ }
+ }
+
+ return $ret[$release];
+ }
+
+ /**
+ * Get a list of roles that require their files to be installed
+ *
+ * Most roles must be installed, but src and package roles, for instance
+ * are pseudo-roles. src files are compiled into a new extension. Package
+ * roles are actually fully bundled releases of a package
+ * @param bool clear cache
+ * @return array
+ */
+ public static function getInstallableRoles($clear = false)
+ {
+ if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
+ PEAR_Installer_Role::registerRoles();
+ }
+
+ static $ret;
+ if ($clear) {
+ unset($ret);
+ }
+
+ if (isset($ret)) {
+ return $ret;
+ }
+
+ $ret = array();
+ foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'] as $role => $okreleases) {
+ if ($okreleases['installable']) {
+ $ret[] = strtolower(str_replace('PEAR_Installer_Role_', '', $role));
+ }
+ }
+
+ return $ret;
+ }
+
+ /**
+ * Return an array of roles that are affected by the baseinstalldir attribute
+ *
+ * Most roles ignore this attribute, and instead install directly into:
+ * PackageName/filepath
+ * so a tests file tests/file.phpt is installed into PackageName/tests/filepath.php
+ * @param bool clear cache
+ * @return array
+ */
+ public static function getBaseinstallRoles($clear = false)
+ {
+ if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
+ PEAR_Installer_Role::registerRoles();
+ }
+
+ static $ret;
+ if ($clear) {
+ unset($ret);
+ }
+
+ if (isset($ret)) {
+ return $ret;
+ }
+
+ $ret = array();
+ foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'] as $role => $okreleases) {
+ if ($okreleases['honorsbaseinstall']) {
+ $ret[] = strtolower(str_replace('PEAR_Installer_Role_', '', $role));
+ }
+ }
+
+ return $ret;
+ }
+
+ /**
+ * Return an array of file roles that should be analyzed for PHP content at package time,
+ * like the "php" role.
+ * @param bool clear cache
+ * @return array
+ */
+ public static function getPhpRoles($clear = false)
+ {
+ if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'])) {
+ PEAR_Installer_Role::registerRoles();
+ }
+
+ static $ret;
+ if ($clear) {
+ unset($ret);
+ }
+
+ if (isset($ret)) {
+ return $ret;
+ }
+
+ $ret = array();
+ foreach ($GLOBALS['_PEAR_INSTALLER_ROLES'] as $role => $okreleases) {
+ if ($okreleases['phpfile']) {
+ $ret[] = strtolower(str_replace('PEAR_Installer_Role_', '', $role));
+ }
+ }
+
+ return $ret;
+ }
+
+ /**
+ * Scan through the Command directory looking for classes
+ * and see what commands they implement.
+ * @param string which directory to look for classes, defaults to
+ * the Installer/Roles subdirectory of
+ * the directory from where this file (__FILE__) is
+ * included.
+ *
+ * @return bool TRUE on success, a PEAR error on failure
+ */
+ public static function registerRoles($dir = null)
+ {
+ $GLOBALS['_PEAR_INSTALLER_ROLES'] = array();
+ $parser = new PEAR_XMLParser;
+ if ($dir === null) {
+ $dir = dirname(__FILE__) . '/Role';
+ }
+
+ if (!file_exists($dir) || !is_dir($dir)) {
+ return PEAR::raiseError("registerRoles: opendir($dir) failed: does not exist/is not directory");
+ }
+
+ $dp = @opendir($dir);
+ if (empty($dp)) {
+ return PEAR::raiseError("registerRoles: opendir($dir) failed: $php_errmsg");
+ }
+
+ while ($entry = readdir($dp)) {
+ if ($entry{0} == '.' || substr($entry, -4) != '.xml') {
+ continue;
+ }
+
+ $class = "PEAR_Installer_Role_".substr($entry, 0, -4);
+ // List of roles
+ if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'][$class])) {
+ $file = "$dir/$entry";
+ $parser->parse(file_get_contents($file));
+ $data = $parser->getData();
+ if (!is_array($data['releasetypes'])) {
+ $data['releasetypes'] = array($data['releasetypes']);
+ }
+
+ $GLOBALS['_PEAR_INSTALLER_ROLES'][$class] = $data;
+ }
+ }
+
+ closedir($dp);
+ ksort($GLOBALS['_PEAR_INSTALLER_ROLES']);
+ PEAR_Installer_Role::getBaseinstallRoles(true);
+ PEAR_Installer_Role::getInstallableRoles(true);
+ PEAR_Installer_Role::getPhpRoles(true);
+ PEAR_Installer_Role::getValidRoles('****', true);
+ return true;
+ }
+} PEAR-1.10.1/PEAR/PackageFile/Generator/v1.php 0000644 0001750 0000144 00000142145 12610427352 017552 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+/**
+ * needed for PEAR_VALIDATE_* constants
+ */
+require_once 'PEAR/Validate.php';
+require_once 'System.php';
+require_once 'PEAR/PackageFile/v2.php';
+/**
+ * This class converts a PEAR_PackageFile_v1 object into any output format.
+ *
+ * Supported output formats include array, XML string, and a PEAR_PackageFile_v2
+ * object, for converting package.xml 1.0 into package.xml 2.0 with no sweat.
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_PackageFile_Generator_v1
+{
+ /**
+ * @var PEAR_PackageFile_v1
+ */
+ var $_packagefile;
+ function __construct(&$packagefile)
+ {
+ $this->_packagefile = &$packagefile;
+ }
+
+ function getPackagerVersion()
+ {
+ return '1.10.1';
+ }
+
+ /**
+ * @param PEAR_Packager
+ * @param bool if true, a .tgz is written, otherwise a .tar is written
+ * @param string|null directory in which to save the .tgz
+ * @return string|PEAR_Error location of package or error object
+ */
+ function toTgz(&$packager, $compress = true, $where = null)
+ {
+ require_once 'Archive/Tar.php';
+ if ($where === null) {
+ if (!($where = System::mktemp(array('-d')))) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: mktemp failed');
+ }
+ } elseif (!@System::mkDir(array('-p', $where))) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: "' . $where . '" could' .
+ ' not be created');
+ }
+ if (file_exists($where . DIRECTORY_SEPARATOR . 'package.xml') &&
+ !is_file($where . DIRECTORY_SEPARATOR . 'package.xml')) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: unable to save package.xml as' .
+ ' "' . $where . DIRECTORY_SEPARATOR . 'package.xml"');
+ }
+ if (!$this->_packagefile->validate(PEAR_VALIDATE_PACKAGING)) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: invalid package file');
+ }
+ $pkginfo = $this->_packagefile->getArray();
+ $ext = $compress ? '.tgz' : '.tar';
+ $pkgver = $pkginfo['package'] . '-' . $pkginfo['version'];
+ $dest_package = getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext;
+ if (file_exists(getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext) &&
+ !is_file(getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext)) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: cannot create tgz file "' .
+ getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext . '"');
+ }
+ if ($pkgfile = $this->_packagefile->getPackageFile()) {
+ $pkgdir = dirname(realpath($pkgfile));
+ $pkgfile = basename($pkgfile);
+ } else {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: package file object must ' .
+ 'be created from a real file');
+ }
+ // {{{ Create the package file list
+ $filelist = array();
+ $i = 0;
+
+ foreach ($this->_packagefile->getFilelist() as $fname => $atts) {
+ $file = $pkgdir . DIRECTORY_SEPARATOR . $fname;
+ if (!file_exists($file)) {
+ return PEAR::raiseError("File does not exist: $fname");
+ } else {
+ $filelist[$i++] = $file;
+ if (!isset($atts['md5sum'])) {
+ $this->_packagefile->setFileAttribute($fname, 'md5sum', md5_file($file));
+ }
+ $packager->log(2, "Adding file $fname");
+ }
+ }
+ // }}}
+ $packagexml = $this->toPackageFile($where, PEAR_VALIDATE_PACKAGING, 'package.xml', true);
+ if ($packagexml) {
+ $tar = new Archive_Tar($dest_package, $compress);
+ $tar->setErrorHandling(PEAR_ERROR_RETURN); // XXX Don't print errors
+ // ----- Creates with the package.xml file
+ $ok = $tar->createModify(array($packagexml), '', $where);
+ if (PEAR::isError($ok)) {
+ return $ok;
+ } elseif (!$ok) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: tarball creation failed');
+ }
+ // ----- Add the content of the package
+ if (!$tar->addModify($filelist, $pkgver, $pkgdir)) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toTgz: tarball creation failed');
+ }
+ return $dest_package;
+ }
+ }
+
+ /**
+ * @param string|null directory to place the package.xml in, or null for a temporary dir
+ * @param int one of the PEAR_VALIDATE_* constants
+ * @param string name of the generated file
+ * @param bool if true, then no analysis will be performed on role="php" files
+ * @return string|PEAR_Error path to the created file on success
+ */
+ function toPackageFile($where = null, $state = PEAR_VALIDATE_NORMAL, $name = 'package.xml',
+ $nofilechecking = false)
+ {
+ if (!$this->_packagefile->validate($state, $nofilechecking)) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: invalid package.xml',
+ null, null, null, $this->_packagefile->getValidationWarnings());
+ }
+ if ($where === null) {
+ if (!($where = System::mktemp(array('-d')))) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: mktemp failed');
+ }
+ } elseif (!@System::mkDir(array('-p', $where))) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: "' . $where . '" could' .
+ ' not be created');
+ }
+ $newpkgfile = $where . DIRECTORY_SEPARATOR . $name;
+ $np = @fopen($newpkgfile, 'wb');
+ if (!$np) {
+ return PEAR::raiseError('PEAR_Packagefile_v1::toPackageFile: unable to save ' .
+ "$name as $newpkgfile");
+ }
+ fwrite($np, $this->toXml($state, true));
+ fclose($np);
+ return $newpkgfile;
+ }
+
+ /**
+ * fix both XML encoding to be UTF8, and replace standard XML entities < > " & '
+ *
+ * @param string $string
+ * @return string
+ * @access private
+ */
+ function _fixXmlEncoding($string)
+ {
+ return strtr($string, array(
+ '&' => '&',
+ '>' => '>',
+ '<' => '<',
+ '"' => '"',
+ '\'' => ''' ));
+ }
+
+ /**
+ * Return an XML document based on the package info (as returned
+ * by the PEAR_Common::infoFrom* methods).
+ *
+ * @return string XML data
+ */
+ function toXml($state = PEAR_VALIDATE_NORMAL, $nofilevalidation = false)
+ {
+ $this->_packagefile->setDate(date('Y-m-d'));
+ if (!$this->_packagefile->validate($state, $nofilevalidation)) {
+ return false;
+ }
+ $pkginfo = $this->_packagefile->getArray();
+ static $maint_map = array(
+ "handle" => "user",
+ "name" => "name",
+ "email" => "email",
+ "role" => "role",
+ );
+ $ret = "\n";
+ $ret .= "\n";
+ $ret .= "\n" .
+" $pkginfo[package]";
+ if (isset($pkginfo['extends'])) {
+ $ret .= "\n$pkginfo[extends]";
+ }
+ $ret .=
+ "\n ".$this->_fixXmlEncoding($pkginfo['summary'])."\n" .
+" ".trim($this->_fixXmlEncoding($pkginfo['description']))."\n \n" .
+" \n";
+ foreach ($pkginfo['maintainers'] as $maint) {
+ $ret .= " \n";
+ foreach ($maint_map as $idx => $elm) {
+ $ret .= " <$elm>";
+ $ret .= $this->_fixXmlEncoding($maint[$idx]);
+ $ret .= "\n";
+ }
+ $ret .= " \n";
+ }
+ $ret .= " \n";
+ $ret .= $this->_makeReleaseXml($pkginfo, false, $state);
+ if (isset($pkginfo['changelog']) && count($pkginfo['changelog']) > 0) {
+ $ret .= " \n";
+ foreach ($pkginfo['changelog'] as $oldrelease) {
+ $ret .= $this->_makeReleaseXml($oldrelease, true);
+ }
+ $ret .= " \n";
+ }
+ $ret .= "\n";
+ return $ret;
+ }
+
+ // }}}
+ // {{{ _makeReleaseXml()
+
+ /**
+ * Generate part of an XML description with release information.
+ *
+ * @param array $pkginfo array with release information
+ * @param bool $changelog whether the result will be in a changelog element
+ *
+ * @return string XML data
+ *
+ * @access private
+ */
+ function _makeReleaseXml($pkginfo, $changelog = false, $state = PEAR_VALIDATE_NORMAL)
+ {
+ // XXX QUOTE ENTITIES IN PCDATA, OR EMBED IN CDATA BLOCKS!!
+ $indent = $changelog ? " " : "";
+ $ret = "$indent \n";
+ if (!empty($pkginfo['version'])) {
+ $ret .= "$indent $pkginfo[version]\n";
+ }
+ if (!empty($pkginfo['release_date'])) {
+ $ret .= "$indent $pkginfo[release_date]\n";
+ }
+ if (!empty($pkginfo['release_license'])) {
+ $ret .= "$indent $pkginfo[release_license]\n";
+ }
+ if (!empty($pkginfo['release_state'])) {
+ $ret .= "$indent $pkginfo[release_state]\n";
+ }
+ if (!empty($pkginfo['release_notes'])) {
+ $ret .= "$indent ".trim($this->_fixXmlEncoding($pkginfo['release_notes']))
+ ."\n$indent \n";
+ }
+ if (!empty($pkginfo['release_warnings'])) {
+ $ret .= "$indent ".$this->_fixXmlEncoding($pkginfo['release_warnings'])."\n";
+ }
+ if (isset($pkginfo['release_deps']) && sizeof($pkginfo['release_deps']) > 0) {
+ $ret .= "$indent \n";
+ foreach ($pkginfo['release_deps'] as $dep) {
+ $ret .= "$indent _fixXmlEncoding($c['name']) . "\"";
+ if (isset($c['default'])) {
+ $ret .= " default=\"" . $this->_fixXmlEncoding($c['default']) . "\"";
+ }
+ $ret .= " prompt=\"" . $this->_fixXmlEncoding($c['prompt']) . "\"";
+ $ret .= "/>\n";
+ }
+ $ret .= "$indent \n";
+ }
+ if (isset($pkginfo['provides'])) {
+ foreach ($pkginfo['provides'] as $key => $what) {
+ $ret .= "$indent recursiveXmlFilelist($pkginfo['filelist']);
+ } else {
+ foreach ($pkginfo['filelist'] as $file => $fa) {
+ if (!isset($fa['role'])) {
+ $fa['role'] = '';
+ }
+ $ret .= "$indent _fixXmlEncoding($fa['baseinstalldir']) . '"';
+ }
+ if (isset($fa['md5sum'])) {
+ $ret .= " md5sum=\"$fa[md5sum]\"";
+ }
+ if (isset($fa['platform'])) {
+ $ret .= " platform=\"$fa[platform]\"";
+ }
+ if (!empty($fa['install-as'])) {
+ $ret .= ' install-as="' .
+ $this->_fixXmlEncoding($fa['install-as']) . '"';
+ }
+ $ret .= ' name="' . $this->_fixXmlEncoding($file) . '"';
+ if (empty($fa['replacements'])) {
+ $ret .= "/>\n";
+ } else {
+ $ret .= ">\n";
+ foreach ($fa['replacements'] as $r) {
+ $ret .= "$indent $v) {
+ $ret .= " $k=\"" . $this->_fixXmlEncoding($v) .'"';
+ }
+ $ret .= "/>\n";
+ }
+ $ret .= "$indent \n";
+ }
+ }
+ }
+ $ret .= "$indent \n";
+ }
+ $ret .= "$indent \n";
+ return $ret;
+ }
+
+ /**
+ * @param array
+ * @access protected
+ */
+ function recursiveXmlFilelist($list)
+ {
+ $this->_dirs = array();
+ foreach ($list as $file => $attributes) {
+ $this->_addDir($this->_dirs, explode('/', dirname($file)), $file, $attributes);
+ }
+ return $this->_formatDir($this->_dirs);
+ }
+
+ /**
+ * @param array
+ * @param array
+ * @param string|null
+ * @param array|null
+ * @access private
+ */
+ function _addDir(&$dirs, $dir, $file = null, $attributes = null)
+ {
+ if ($dir == array() || $dir == array('.')) {
+ $dirs['files'][basename($file)] = $attributes;
+ return;
+ }
+ $curdir = array_shift($dir);
+ if (!isset($dirs['dirs'][$curdir])) {
+ $dirs['dirs'][$curdir] = array();
+ }
+ $this->_addDir($dirs['dirs'][$curdir], $dir, $file, $attributes);
+ }
+
+ /**
+ * @param array
+ * @param string
+ * @param string
+ * @access private
+ */
+ function _formatDir($dirs, $indent = '', $curdir = '')
+ {
+ $ret = '';
+ if (!count($dirs)) {
+ return '';
+ }
+ if (isset($dirs['dirs'])) {
+ uksort($dirs['dirs'], 'strnatcasecmp');
+ foreach ($dirs['dirs'] as $dir => $contents) {
+ $usedir = "$curdir/$dir";
+ $ret .= "$indent \n";
+ $ret .= $this->_formatDir($contents, "$indent ", $usedir);
+ $ret .= "$indent \n";
+ }
+ }
+ if (isset($dirs['files'])) {
+ uksort($dirs['files'], 'strnatcasecmp');
+ foreach ($dirs['files'] as $file => $attribs) {
+ $ret .= $this->_formatFile($file, $attribs, $indent);
+ }
+ }
+ return $ret;
+ }
+
+ /**
+ * @param string
+ * @param array
+ * @param string
+ * @access private
+ */
+ function _formatFile($file, $attributes, $indent)
+ {
+ $ret = "$indent _fixXmlEncoding($attributes['baseinstalldir']) . '"';
+ }
+ if (isset($attributes['md5sum'])) {
+ $ret .= " md5sum=\"$attributes[md5sum]\"";
+ }
+ if (isset($attributes['platform'])) {
+ $ret .= " platform=\"$attributes[platform]\"";
+ }
+ if (!empty($attributes['install-as'])) {
+ $ret .= ' install-as="' .
+ $this->_fixXmlEncoding($attributes['install-as']) . '"';
+ }
+ $ret .= ' name="' . $this->_fixXmlEncoding($file) . '"';
+ if (empty($attributes['replacements'])) {
+ $ret .= "/>\n";
+ } else {
+ $ret .= ">\n";
+ foreach ($attributes['replacements'] as $r) {
+ $ret .= "$indent $v) {
+ $ret .= " $k=\"" . $this->_fixXmlEncoding($v) .'"';
+ }
+ $ret .= "/>\n";
+ }
+ $ret .= "$indent \n";
+ }
+ return $ret;
+ }
+
+ // {{{ _unIndent()
+
+ /**
+ * Unindent given string (?)
+ *
+ * @param string $str The string that has to be unindented.
+ * @return string
+ * @access private
+ */
+ function _unIndent($str)
+ {
+ // remove leading newlines
+ $str = preg_replace('/^[\r\n]+/', '', $str);
+ // find whitespace at the beginning of the first line
+ $indent_len = strspn($str, " \t");
+ $indent = substr($str, 0, $indent_len);
+ $data = '';
+ // remove the same amount of whitespace from following lines
+ foreach (explode("\n", $str) as $line) {
+ if (substr($line, 0, $indent_len) == $indent) {
+ $data .= substr($line, $indent_len) . "\n";
+ }
+ }
+ return $data;
+ }
+
+ /**
+ * @return array
+ */
+ function dependenciesToV2()
+ {
+ $arr = array();
+ $this->_convertDependencies2_0($arr);
+ return $arr['dependencies'];
+ }
+
+ /**
+ * Convert a package.xml version 1.0 into version 2.0
+ *
+ * Note that this does a basic conversion, to allow more advanced
+ * features like bundles and multiple releases
+ * @param string the classname to instantiate and return. This must be
+ * PEAR_PackageFile_v2 or a descendant
+ * @param boolean if true, only valid, deterministic package.xml 1.0 as defined by the
+ * strictest parameters will be converted
+ * @return PEAR_PackageFile_v2|PEAR_Error
+ */
+ function &toV2($class = 'PEAR_PackageFile_v2', $strict = false)
+ {
+ if ($strict) {
+ if (!$this->_packagefile->validate()) {
+ $a = PEAR::raiseError('invalid package.xml version 1.0 cannot be converted' .
+ ' to version 2.0', null, null, null,
+ $this->_packagefile->getValidationWarnings(true));
+ return $a;
+ }
+ }
+
+ $arr = array(
+ 'attribs' => array(
+ 'version' => '2.0',
+ 'xmlns' => 'http://pear.php.net/dtd/package-2.0',
+ 'xmlns:tasks' => 'http://pear.php.net/dtd/tasks-1.0',
+ 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+ 'xsi:schemaLocation' => "http://pear.php.net/dtd/tasks-1.0\n" .
+"http://pear.php.net/dtd/tasks-1.0.xsd\n" .
+"http://pear.php.net/dtd/package-2.0\n" .
+'http://pear.php.net/dtd/package-2.0.xsd',
+ ),
+ 'name' => $this->_packagefile->getPackage(),
+ 'channel' => 'pear.php.net',
+ );
+ $arr['summary'] = $this->_packagefile->getSummary();
+ $arr['description'] = $this->_packagefile->getDescription();
+ $maintainers = $this->_packagefile->getMaintainers();
+ foreach ($maintainers as $maintainer) {
+ if ($maintainer['role'] != 'lead') {
+ continue;
+ }
+ $new = array(
+ 'name' => $maintainer['name'],
+ 'user' => $maintainer['handle'],
+ 'email' => $maintainer['email'],
+ 'active' => 'yes',
+ );
+ $arr['lead'][] = $new;
+ }
+
+ if (!isset($arr['lead'])) { // some people... you know?
+ $arr['lead'] = array(
+ 'name' => 'unknown',
+ 'user' => 'unknown',
+ 'email' => 'noleadmaintainer@example.com',
+ 'active' => 'no',
+ );
+ }
+
+ if (count($arr['lead']) == 1) {
+ $arr['lead'] = $arr['lead'][0];
+ }
+
+ foreach ($maintainers as $maintainer) {
+ if ($maintainer['role'] == 'lead') {
+ continue;
+ }
+ $new = array(
+ 'name' => $maintainer['name'],
+ 'user' => $maintainer['handle'],
+ 'email' => $maintainer['email'],
+ 'active' => 'yes',
+ );
+ $arr[$maintainer['role']][] = $new;
+ }
+
+ if (isset($arr['developer']) && count($arr['developer']) == 1) {
+ $arr['developer'] = $arr['developer'][0];
+ }
+
+ if (isset($arr['contributor']) && count($arr['contributor']) == 1) {
+ $arr['contributor'] = $arr['contributor'][0];
+ }
+
+ if (isset($arr['helper']) && count($arr['helper']) == 1) {
+ $arr['helper'] = $arr['helper'][0];
+ }
+
+ $arr['date'] = $this->_packagefile->getDate();
+ $arr['version'] =
+ array(
+ 'release' => $this->_packagefile->getVersion(),
+ 'api' => $this->_packagefile->getVersion(),
+ );
+ $arr['stability'] =
+ array(
+ 'release' => $this->_packagefile->getState(),
+ 'api' => $this->_packagefile->getState(),
+ );
+ $licensemap =
+ array(
+ 'php' => 'http://www.php.net/license',
+ 'php license' => 'http://www.php.net/license',
+ 'lgpl' => 'http://www.gnu.org/copyleft/lesser.html',
+ 'bsd' => 'http://www.opensource.org/licenses/bsd-license.php',
+ 'bsd style' => 'http://www.opensource.org/licenses/bsd-license.php',
+ 'bsd-style' => 'http://www.opensource.org/licenses/bsd-license.php',
+ 'mit' => 'http://www.opensource.org/licenses/mit-license.php',
+ 'gpl' => 'http://www.gnu.org/copyleft/gpl.html',
+ 'apache' => 'http://www.opensource.org/licenses/apache2.0.php'
+ );
+
+ if (isset($licensemap[strtolower($this->_packagefile->getLicense())])) {
+ $arr['license'] = array(
+ 'attribs' => array('uri' =>
+ $licensemap[strtolower($this->_packagefile->getLicense())]),
+ '_content' => $this->_packagefile->getLicense()
+ );
+ } else {
+ // don't use bogus uri
+ $arr['license'] = $this->_packagefile->getLicense();
+ }
+
+ $arr['notes'] = $this->_packagefile->getNotes();
+ $temp = array();
+ $arr['contents'] = $this->_convertFilelist2_0($temp);
+ $this->_convertDependencies2_0($arr);
+ $release = ($this->_packagefile->getConfigureOptions() || $this->_isExtension) ?
+ 'extsrcrelease' : 'phprelease';
+ if ($release == 'extsrcrelease') {
+ $arr['channel'] = 'pecl.php.net';
+ $arr['providesextension'] = $arr['name']; // assumption
+ }
+
+ $arr[$release] = array();
+ if ($this->_packagefile->getConfigureOptions()) {
+ $arr[$release]['configureoption'] = $this->_packagefile->getConfigureOptions();
+ foreach ($arr[$release]['configureoption'] as $i => $opt) {
+ $arr[$release]['configureoption'][$i] = array('attribs' => $opt);
+ }
+ if (count($arr[$release]['configureoption']) == 1) {
+ $arr[$release]['configureoption'] = $arr[$release]['configureoption'][0];
+ }
+ }
+
+ $this->_convertRelease2_0($arr[$release], $temp);
+ if ($release == 'extsrcrelease' && count($arr[$release]) > 1) {
+ // multiple extsrcrelease tags added in PEAR 1.4.1
+ $arr['dependencies']['required']['pearinstaller']['min'] = '1.4.1';
+ }
+
+ if ($cl = $this->_packagefile->getChangelog()) {
+ foreach ($cl as $release) {
+ $rel = array();
+ $rel['version'] =
+ array(
+ 'release' => $release['version'],
+ 'api' => $release['version'],
+ );
+ if (!isset($release['release_state'])) {
+ $release['release_state'] = 'stable';
+ }
+
+ $rel['stability'] =
+ array(
+ 'release' => $release['release_state'],
+ 'api' => $release['release_state'],
+ );
+ if (isset($release['release_date'])) {
+ $rel['date'] = $release['release_date'];
+ } else {
+ $rel['date'] = date('Y-m-d');
+ }
+
+ if (isset($release['release_license'])) {
+ if (isset($licensemap[strtolower($release['release_license'])])) {
+ $uri = $licensemap[strtolower($release['release_license'])];
+ } else {
+ $uri = 'http://www.example.com';
+ }
+ $rel['license'] = array(
+ 'attribs' => array('uri' => $uri),
+ '_content' => $release['release_license']
+ );
+ } else {
+ $rel['license'] = $arr['license'];
+ }
+
+ if (!isset($release['release_notes'])) {
+ $release['release_notes'] = 'no release notes';
+ }
+
+ $rel['notes'] = $release['release_notes'];
+ $arr['changelog']['release'][] = $rel;
+ }
+ }
+
+ $ret = new $class;
+ $ret->setConfig($this->_packagefile->_config);
+ if (isset($this->_packagefile->_logger) && is_object($this->_packagefile->_logger)) {
+ $ret->setLogger($this->_packagefile->_logger);
+ }
+
+ $ret->fromArray($arr);
+ return $ret;
+ }
+
+ /**
+ * @param array
+ * @param bool
+ * @access private
+ */
+ function _convertDependencies2_0(&$release, $internal = false)
+ {
+ $peardep = array('pearinstaller' =>
+ array('min' => '1.4.0b1')); // this is a lot safer
+ $required = $optional = array();
+ $release['dependencies'] = array('required' => array());
+ if ($this->_packagefile->hasDeps()) {
+ foreach ($this->_packagefile->getDeps() as $dep) {
+ if (!isset($dep['optional']) || $dep['optional'] == 'no') {
+ $required[] = $dep;
+ } else {
+ $optional[] = $dep;
+ }
+ }
+ foreach (array('required', 'optional') as $arr) {
+ $deps = array();
+ foreach ($$arr as $dep) {
+ // organize deps by dependency type and name
+ if (!isset($deps[$dep['type']])) {
+ $deps[$dep['type']] = array();
+ }
+ if (isset($dep['name'])) {
+ $deps[$dep['type']][$dep['name']][] = $dep;
+ } else {
+ $deps[$dep['type']][] = $dep;
+ }
+ }
+ do {
+ if (isset($deps['php'])) {
+ $php = array();
+ if (count($deps['php']) > 1) {
+ $php = $this->_processPhpDeps($deps['php']);
+ } else {
+ if (!isset($deps['php'][0])) {
+ list($key, $blah) = each ($deps['php']); // stupid buggy versions
+ $deps['php'] = array($blah[0]);
+ }
+ $php = $this->_processDep($deps['php'][0]);
+ if (!$php) {
+ break; // poor mans throw
+ }
+ }
+ $release['dependencies'][$arr]['php'] = $php;
+ }
+ } while (false);
+ do {
+ if (isset($deps['pkg'])) {
+ $pkg = array();
+ $pkg = $this->_processMultipleDepsName($deps['pkg']);
+ if (!$pkg) {
+ break; // poor mans throw
+ }
+ $release['dependencies'][$arr]['package'] = $pkg;
+ }
+ } while (false);
+ do {
+ if (isset($deps['ext'])) {
+ $pkg = array();
+ $pkg = $this->_processMultipleDepsName($deps['ext']);
+ $release['dependencies'][$arr]['extension'] = $pkg;
+ }
+ } while (false);
+ // skip sapi - it's not supported so nobody will have used it
+ // skip os - it's not supported in 1.0
+ }
+ }
+ if (isset($release['dependencies']['required'])) {
+ $release['dependencies']['required'] =
+ array_merge($peardep, $release['dependencies']['required']);
+ } else {
+ $release['dependencies']['required'] = $peardep;
+ }
+ if (!isset($release['dependencies']['required']['php'])) {
+ $release['dependencies']['required']['php'] =
+ array('min' => '4.0.0');
+ }
+ $order = array();
+ $bewm = $release['dependencies']['required'];
+ $order['php'] = $bewm['php'];
+ $order['pearinstaller'] = $bewm['pearinstaller'];
+ isset($bewm['package']) ? $order['package'] = $bewm['package'] :0;
+ isset($bewm['extension']) ? $order['extension'] = $bewm['extension'] :0;
+ $release['dependencies']['required'] = $order;
+ }
+
+ /**
+ * @param array
+ * @access private
+ */
+ function _convertFilelist2_0(&$package)
+ {
+ $ret = array('dir' =>
+ array(
+ 'attribs' => array('name' => '/'),
+ 'file' => array()
+ )
+ );
+ $package['platform'] =
+ $package['install-as'] = array();
+ $this->_isExtension = false;
+ foreach ($this->_packagefile->getFilelist() as $name => $file) {
+ $file['name'] = $name;
+ if (isset($file['role']) && $file['role'] == 'src') {
+ $this->_isExtension = true;
+ }
+ if (isset($file['replacements'])) {
+ $repl = $file['replacements'];
+ unset($file['replacements']);
+ } else {
+ unset($repl);
+ }
+ if (isset($file['install-as'])) {
+ $package['install-as'][$name] = $file['install-as'];
+ unset($file['install-as']);
+ }
+ if (isset($file['platform'])) {
+ $package['platform'][$name] = $file['platform'];
+ unset($file['platform']);
+ }
+ $file = array('attribs' => $file);
+ if (isset($repl)) {
+ foreach ($repl as $replace ) {
+ $file['tasks:replace'][] = array('attribs' => $replace);
+ }
+ if (count($repl) == 1) {
+ $file['tasks:replace'] = $file['tasks:replace'][0];
+ }
+ }
+ $ret['dir']['file'][] = $file;
+ }
+ return $ret;
+ }
+
+ /**
+ * Post-process special files with install-as/platform attributes and
+ * make the release tag.
+ *
+ * This complex method follows this work-flow to create the release tags:
+ *
+ *
+ * - if any install-as/platform exist, create a generic release and fill it with
+ * o tags for
+ * o tags for
+ * o tags for
+ * o tags for
+ * - create a release for each platform encountered and fill with
+ * o tags for
+ * o tags for
+ * o tags for
+ * o tags for
+ * o tags for
+ * o tags for
+ * o tags for
+ *
+ *
+ * It does this by accessing the $package parameter, which contains an array with
+ * indices:
+ *
+ * - platform: mapping of file => OS the file should be installed on
+ * - install-as: mapping of file => installed name
+ * - osmap: mapping of OS => list of files that should be installed
+ * on that OS
+ * - notosmap: mapping of OS => list of files that should not be
+ * installed on that OS
+ *
+ * @param array
+ * @param array
+ * @access private
+ */
+ function _convertRelease2_0(&$release, $package)
+ {
+ //- if any install-as/platform exist, create a generic release and fill it with
+ if (count($package['platform']) || count($package['install-as'])) {
+ $generic = array();
+ $genericIgnore = array();
+ foreach ($package['install-as'] as $file => $as) {
+ //o tags for
+ if (!isset($package['platform'][$file])) {
+ $generic[] = $file;
+ continue;
+ }
+ //o tags for
+ if (isset($package['platform'][$file]) &&
+ $package['platform'][$file]{0} == '!') {
+ $generic[] = $file;
+ continue;
+ }
+ //o tags for
+ if (isset($package['platform'][$file]) &&
+ $package['platform'][$file]{0} != '!') {
+ $genericIgnore[] = $file;
+ continue;
+ }
+ }
+ foreach ($package['platform'] as $file => $platform) {
+ if (isset($package['install-as'][$file])) {
+ continue;
+ }
+ if ($platform{0} != '!') {
+ //o tags for
+ $genericIgnore[] = $file;
+ }
+ }
+ if (count($package['platform'])) {
+ $oses = $notplatform = $platform = array();
+ foreach ($package['platform'] as $file => $os) {
+ // get a list of oses
+ if ($os{0} == '!') {
+ if (isset($oses[substr($os, 1)])) {
+ continue;
+ }
+ $oses[substr($os, 1)] = count($oses);
+ } else {
+ if (isset($oses[$os])) {
+ continue;
+ }
+ $oses[$os] = count($oses);
+ }
+ }
+ //- create a release for each platform encountered and fill with
+ foreach ($oses as $os => $releaseNum) {
+ $release[$releaseNum]['installconditions']['os']['name'] = $os;
+ $release[$releaseNum]['filelist'] = array('install' => array(),
+ 'ignore' => array());
+ foreach ($package['install-as'] as $file => $as) {
+ //o tags for
+ if (!isset($package['platform'][$file])) {
+ $release[$releaseNum]['filelist']['install'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ 'as' => $as,
+ ),
+ );
+ continue;
+ }
+ //o tags for
+ //
+ if (isset($package['platform'][$file]) &&
+ $package['platform'][$file] == $os) {
+ $release[$releaseNum]['filelist']['install'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ 'as' => $as,
+ ),
+ );
+ continue;
+ }
+ //o tags for
+ //
+ if (isset($package['platform'][$file]) &&
+ $package['platform'][$file] != "!$os" &&
+ $package['platform'][$file]{0} == '!') {
+ $release[$releaseNum]['filelist']['install'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ 'as' => $as,
+ ),
+ );
+ continue;
+ }
+ //o tags for
+ //
+ if (isset($package['platform'][$file]) &&
+ $package['platform'][$file] == "!$os") {
+ $release[$releaseNum]['filelist']['ignore'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ ),
+ );
+ continue;
+ }
+ //o tags for
+ //
+ if (isset($package['platform'][$file]) &&
+ $package['platform'][$file]{0} != '!' &&
+ $package['platform'][$file] != $os) {
+ $release[$releaseNum]['filelist']['ignore'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ ),
+ );
+ continue;
+ }
+ }
+ foreach ($package['platform'] as $file => $platform) {
+ if (isset($package['install-as'][$file])) {
+ continue;
+ }
+ //o tags for
+ if ($platform == "!$os") {
+ $release[$releaseNum]['filelist']['ignore'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ ),
+ );
+ continue;
+ }
+ //o tags for
+ if ($platform{0} != '!' && $platform != $os) {
+ $release[$releaseNum]['filelist']['ignore'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ ),
+ );
+ }
+ }
+ if (!count($release[$releaseNum]['filelist']['install'])) {
+ unset($release[$releaseNum]['filelist']['install']);
+ }
+ if (!count($release[$releaseNum]['filelist']['ignore'])) {
+ unset($release[$releaseNum]['filelist']['ignore']);
+ }
+ }
+ if (count($generic) || count($genericIgnore)) {
+ $release[count($oses)] = array();
+ if (count($generic)) {
+ foreach ($generic as $file) {
+ if (isset($package['install-as'][$file])) {
+ $installas = $package['install-as'][$file];
+ } else {
+ $installas = $file;
+ }
+ $release[count($oses)]['filelist']['install'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ 'as' => $installas,
+ )
+ );
+ }
+ }
+ if (count($genericIgnore)) {
+ foreach ($genericIgnore as $file) {
+ $release[count($oses)]['filelist']['ignore'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ )
+ );
+ }
+ }
+ }
+ // cleanup
+ foreach ($release as $i => $rel) {
+ if (isset($rel['filelist']['install']) &&
+ count($rel['filelist']['install']) == 1) {
+ $release[$i]['filelist']['install'] =
+ $release[$i]['filelist']['install'][0];
+ }
+ if (isset($rel['filelist']['ignore']) &&
+ count($rel['filelist']['ignore']) == 1) {
+ $release[$i]['filelist']['ignore'] =
+ $release[$i]['filelist']['ignore'][0];
+ }
+ }
+ if (count($release) == 1) {
+ $release = $release[0];
+ }
+ } else {
+ // no platform atts, but some install-as atts
+ foreach ($package['install-as'] as $file => $value) {
+ $release['filelist']['install'][] =
+ array(
+ 'attribs' => array(
+ 'name' => $file,
+ 'as' => $value
+ )
+ );
+ }
+ if (count($release['filelist']['install']) == 1) {
+ $release['filelist']['install'] = $release['filelist']['install'][0];
+ }
+ }
+ }
+ }
+
+ /**
+ * @param array
+ * @return array
+ * @access private
+ */
+ function _processDep($dep)
+ {
+ if ($dep['type'] == 'php') {
+ if ($dep['rel'] == 'has') {
+ // come on - everyone has php!
+ return false;
+ }
+ }
+ $php = array();
+ if ($dep['type'] != 'php') {
+ $php['name'] = $dep['name'];
+ if ($dep['type'] == 'pkg') {
+ $php['channel'] = 'pear.php.net';
+ }
+ }
+ switch ($dep['rel']) {
+ case 'gt' :
+ $php['min'] = $dep['version'];
+ $php['exclude'] = $dep['version'];
+ break;
+ case 'ge' :
+ if (!isset($dep['version'])) {
+ if ($dep['type'] == 'php') {
+ if (isset($dep['name'])) {
+ $dep['version'] = $dep['name'];
+ }
+ }
+ }
+ $php['min'] = $dep['version'];
+ break;
+ case 'lt' :
+ $php['max'] = $dep['version'];
+ $php['exclude'] = $dep['version'];
+ break;
+ case 'le' :
+ $php['max'] = $dep['version'];
+ break;
+ case 'eq' :
+ $php['min'] = $dep['version'];
+ $php['max'] = $dep['version'];
+ break;
+ case 'ne' :
+ $php['exclude'] = $dep['version'];
+ break;
+ case 'not' :
+ $php['conflicts'] = 'yes';
+ break;
+ }
+ return $php;
+ }
+
+ /**
+ * @param array
+ * @return array
+ */
+ function _processPhpDeps($deps)
+ {
+ $test = array();
+ foreach ($deps as $dep) {
+ $test[] = $this->_processDep($dep);
+ }
+ $min = array();
+ $max = array();
+ foreach ($test as $dep) {
+ if (!$dep) {
+ continue;
+ }
+ if (isset($dep['min'])) {
+ $min[$dep['min']] = count($min);
+ }
+ if (isset($dep['max'])) {
+ $max[$dep['max']] = count($max);
+ }
+ }
+ if (count($min) > 0) {
+ uksort($min, 'version_compare');
+ }
+ if (count($max) > 0) {
+ uksort($max, 'version_compare');
+ }
+ if (count($min)) {
+ // get the highest minimum
+ $a = array_flip($min);
+ $min = array_pop($a);
+ } else {
+ $min = false;
+ }
+ if (count($max)) {
+ // get the lowest maximum
+ $a = array_flip($max);
+ $max = array_shift($a);
+ } else {
+ $max = false;
+ }
+ if ($min) {
+ $php['min'] = $min;
+ }
+ if ($max) {
+ $php['max'] = $max;
+ }
+ $exclude = array();
+ foreach ($test as $dep) {
+ if (!isset($dep['exclude'])) {
+ continue;
+ }
+ $exclude[] = $dep['exclude'];
+ }
+ if (count($exclude)) {
+ $php['exclude'] = $exclude;
+ }
+ return $php;
+ }
+
+ /**
+ * process multiple dependencies that have a name, like package deps
+ * @param array
+ * @return array
+ * @access private
+ */
+ function _processMultipleDepsName($deps)
+ {
+ $ret = $tests = array();
+ foreach ($deps as $name => $dep) {
+ foreach ($dep as $d) {
+ $tests[$name][] = $this->_processDep($d);
+ }
+ }
+
+ foreach ($tests as $name => $test) {
+ $max = $min = $php = array();
+ $php['name'] = $name;
+ foreach ($test as $dep) {
+ if (!$dep) {
+ continue;
+ }
+ if (isset($dep['channel'])) {
+ $php['channel'] = 'pear.php.net';
+ }
+ if (isset($dep['conflicts']) && $dep['conflicts'] == 'yes') {
+ $php['conflicts'] = 'yes';
+ }
+ if (isset($dep['min'])) {
+ $min[$dep['min']] = count($min);
+ }
+ if (isset($dep['max'])) {
+ $max[$dep['max']] = count($max);
+ }
+ }
+ if (count($min) > 0) {
+ uksort($min, 'version_compare');
+ }
+ if (count($max) > 0) {
+ uksort($max, 'version_compare');
+ }
+ if (count($min)) {
+ // get the highest minimum
+ $a = array_flip($min);
+ $min = array_pop($a);
+ } else {
+ $min = false;
+ }
+ if (count($max)) {
+ // get the lowest maximum
+ $a = array_flip($max);
+ $max = array_shift($a);
+ } else {
+ $max = false;
+ }
+ if ($min) {
+ $php['min'] = $min;
+ }
+ if ($max) {
+ $php['max'] = $max;
+ }
+ $exclude = array();
+ foreach ($test as $dep) {
+ if (!isset($dep['exclude'])) {
+ continue;
+ }
+ $exclude[] = $dep['exclude'];
+ }
+ if (count($exclude)) {
+ $php['exclude'] = $exclude;
+ }
+ $ret[] = $php;
+ }
+ return $ret;
+ }
+}
+?>
+ PEAR-1.10.1/PEAR/PackageFile/Generator/v2.php 0000644 0001750 0000144 00000100706 12610427352 017550 0 ustar cweiske users
+ * @author Stephan Schmidt (original XML_Serializer code)
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+/**
+ * file/dir manipulation routines
+ */
+require_once 'System.php';
+require_once 'XML/Util.php';
+
+/**
+ * This class converts a PEAR_PackageFile_v2 object into any output format.
+ *
+ * Supported output formats include array, XML string (using S. Schmidt's
+ * XML_Serializer, slightly customized)
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @author Stephan Schmidt (original XML_Serializer code)
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_PackageFile_Generator_v2
+{
+ /**
+ * default options for the serialization
+ * @access private
+ * @var array $_defaultOptions
+ */
+ var $_defaultOptions = array(
+ 'indent' => ' ', // string used for indentation
+ 'linebreak' => "\n", // string used for newlines
+ 'typeHints' => false, // automatically add type hin attributes
+ 'addDecl' => true, // add an XML declaration
+ 'defaultTagName' => 'XML_Serializer_Tag', // tag used for indexed arrays or invalid names
+ 'classAsTagName' => false, // use classname for objects in indexed arrays
+ 'keyAttribute' => '_originalKey', // attribute where original key is stored
+ 'typeAttribute' => '_type', // attribute for type (only if typeHints => true)
+ 'classAttribute' => '_class', // attribute for class of objects (only if typeHints => true)
+ 'scalarAsAttributes' => false, // scalar values (strings, ints,..) will be serialized as attribute
+ 'prependAttributes' => '', // prepend string for attributes
+ 'indentAttributes' => false, // indent the attributes, if set to '_auto', it will indent attributes so they all start at the same column
+ 'mode' => 'simplexml', // use 'simplexml' to use parent name as tagname if transforming an indexed array
+ 'addDoctype' => false, // add a doctype declaration
+ 'doctype' => null, // supply a string or an array with id and uri ({@see XML_Util::getDoctypeDeclaration()}
+ 'rootName' => 'package', // name of the root tag
+ 'rootAttributes' => array(
+ 'version' => '2.0',
+ 'xmlns' => 'http://pear.php.net/dtd/package-2.0',
+ 'xmlns:tasks' => 'http://pear.php.net/dtd/tasks-1.0',
+ 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+ 'xsi:schemaLocation' => 'http://pear.php.net/dtd/tasks-1.0
+http://pear.php.net/dtd/tasks-1.0.xsd
+http://pear.php.net/dtd/package-2.0
+http://pear.php.net/dtd/package-2.0.xsd',
+ ), // attributes of the root tag
+ 'attributesArray' => 'attribs', // all values in this key will be treated as attributes
+ 'contentName' => '_content', // this value will be used directly as content, instead of creating a new tag, may only be used in conjunction with attributesArray
+ 'beautifyFilelist' => false,
+ 'encoding' => 'UTF-8',
+ );
+
+ /**
+ * options for the serialization
+ * @access private
+ * @var array $options
+ */
+ var $options = array();
+
+ /**
+ * current tag depth
+ * @var integer $_tagDepth
+ */
+ var $_tagDepth = 0;
+
+ /**
+ * serilialized representation of the data
+ * @var string $_serializedData
+ */
+ var $_serializedData = null;
+ /**
+ * @var PEAR_PackageFile_v2
+ */
+ var $_packagefile;
+ /**
+ * @param PEAR_PackageFile_v2
+ */
+ function __construct(&$packagefile)
+ {
+ $this->_packagefile = &$packagefile;
+ if (isset($this->_packagefile->encoding)) {
+ $this->_defaultOptions['encoding'] = $this->_packagefile->encoding;
+ }
+ }
+
+ /**
+ * @return string
+ */
+ function getPackagerVersion()
+ {
+ return '1.10.1';
+ }
+
+ /**
+ * @param PEAR_Packager
+ * @param bool generate a .tgz or a .tar
+ * @param string|null temporary directory to package in
+ */
+ function toTgz(&$packager, $compress = true, $where = null)
+ {
+ $a = null;
+ return $this->toTgz2($packager, $a, $compress, $where);
+ }
+
+ /**
+ * Package up both a package.xml and package2.xml for the same release
+ * @param PEAR_Packager
+ * @param PEAR_PackageFile_v1
+ * @param bool generate a .tgz or a .tar
+ * @param string|null temporary directory to package in
+ */
+ function toTgz2(&$packager, &$pf1, $compress = true, $where = null)
+ {
+ require_once 'Archive/Tar.php';
+ if (!$this->_packagefile->isEquivalent($pf1)) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toTgz: "' .
+ basename($pf1->getPackageFile()) .
+ '" is not equivalent to "' . basename($this->_packagefile->getPackageFile())
+ . '"');
+ }
+
+ if ($where === null) {
+ if (!($where = System::mktemp(array('-d')))) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toTgz: mktemp failed');
+ }
+ } elseif (!@System::mkDir(array('-p', $where))) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toTgz: "' . $where . '" could' .
+ ' not be created');
+ }
+
+ $file = $where . DIRECTORY_SEPARATOR . 'package.xml';
+ if (file_exists($file) && !is_file($file)) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toTgz: unable to save package.xml as' .
+ ' "' . $file .'"');
+ }
+
+ if (!$this->_packagefile->validate(PEAR_VALIDATE_PACKAGING)) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toTgz: invalid package.xml');
+ }
+
+ $ext = $compress ? '.tgz' : '.tar';
+ $pkgver = $this->_packagefile->getPackage() . '-' . $this->_packagefile->getVersion();
+ $dest_package = getcwd() . DIRECTORY_SEPARATOR . $pkgver . $ext;
+ if (file_exists($dest_package) && !is_file($dest_package)) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toTgz: cannot create tgz file "' .
+ $dest_package . '"');
+ }
+
+ $pkgfile = $this->_packagefile->getPackageFile();
+ if (!$pkgfile) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toTgz: package file object must ' .
+ 'be created from a real file');
+ }
+
+ $pkgdir = dirname(realpath($pkgfile));
+ $pkgfile = basename($pkgfile);
+
+ // {{{ Create the package file list
+ $filelist = array();
+ $i = 0;
+ $this->_packagefile->flattenFilelist();
+ $contents = $this->_packagefile->getContents();
+ if (isset($contents['bundledpackage'])) { // bundles of packages
+ $contents = $contents['bundledpackage'];
+ if (!isset($contents[0])) {
+ $contents = array($contents);
+ }
+
+ $packageDir = $where;
+ foreach ($contents as $i => $package) {
+ $fname = $package;
+ $file = $pkgdir . DIRECTORY_SEPARATOR . $fname;
+ if (!file_exists($file)) {
+ return $packager->raiseError("File does not exist: $fname");
+ }
+
+ $tfile = $packageDir . DIRECTORY_SEPARATOR . $fname;
+ System::mkdir(array('-p', dirname($tfile)));
+ copy($file, $tfile);
+ $filelist[$i++] = $tfile;
+ $packager->log(2, "Adding package $fname");
+ }
+ } else { // normal packages
+ $contents = $contents['dir']['file'];
+ if (!isset($contents[0])) {
+ $contents = array($contents);
+ }
+
+ $packageDir = $where;
+ foreach ($contents as $i => $file) {
+ $fname = $file['attribs']['name'];
+ $atts = $file['attribs'];
+ $orig = $file;
+ $file = $pkgdir . DIRECTORY_SEPARATOR . $fname;
+ if (!file_exists($file)) {
+ return $packager->raiseError("File does not exist: $fname");
+ }
+
+ $origperms = fileperms($file);
+ $tfile = $packageDir . DIRECTORY_SEPARATOR . $fname;
+ unset($orig['attribs']);
+ if (count($orig)) { // file with tasks
+ // run any package-time tasks
+ $contents = file_get_contents($file);
+ foreach ($orig as $tag => $raw) {
+ $tag = str_replace(
+ array($this->_packagefile->getTasksNs() . ':', '-'),
+ array('', '_'), $tag);
+ $task = "PEAR_Task_$tag";
+ $task = new $task($this->_packagefile->_config,
+ $this->_packagefile->_logger,
+ PEAR_TASK_PACKAGE);
+ $task->init($raw, $atts, null);
+ $res = $task->startSession($this->_packagefile, $contents, $tfile);
+ if (!$res) {
+ continue; // skip this task
+ }
+
+ if (PEAR::isError($res)) {
+ return $res;
+ }
+
+ $contents = $res; // save changes
+ System::mkdir(array('-p', dirname($tfile)));
+ $wp = fopen($tfile, "wb");
+ fwrite($wp, $contents);
+ fclose($wp);
+ }
+ }
+
+ if (!file_exists($tfile)) {
+ System::mkdir(array('-p', dirname($tfile)));
+ copy($file, $tfile);
+ }
+
+ chmod($tfile, $origperms);
+ $filelist[$i++] = $tfile;
+ $this->_packagefile->setFileAttribute($fname, 'md5sum', md5_file($tfile), $i - 1);
+ $packager->log(2, "Adding file $fname");
+ }
+ }
+ // }}}
+
+ $name = $pf1 !== null ? 'package2.xml' : 'package.xml';
+ $packagexml = $this->toPackageFile($where, PEAR_VALIDATE_PACKAGING, $name);
+ if ($packagexml) {
+ $tar = new Archive_Tar($dest_package, $compress);
+ $tar->setErrorHandling(PEAR_ERROR_RETURN); // XXX Don't print errors
+ // ----- Creates with the package.xml file
+ $ok = $tar->createModify(array($packagexml), '', $where);
+ if (PEAR::isError($ok)) {
+ return $packager->raiseError($ok);
+ } elseif (!$ok) {
+ return $packager->raiseError('PEAR_Packagefile_v2::toTgz(): adding ' . $name .
+ ' failed');
+ }
+
+ // ----- Add the content of the package
+ if (!$tar->addModify($filelist, $pkgver, $where)) {
+ return $packager->raiseError(
+ 'PEAR_Packagefile_v2::toTgz(): tarball creation failed');
+ }
+
+ // add the package.xml version 1.0
+ if ($pf1 !== null) {
+ $pfgen = &$pf1->getDefaultGenerator();
+ $packagexml1 = $pfgen->toPackageFile($where, PEAR_VALIDATE_PACKAGING, 'package.xml', true);
+ if (!$tar->addModify(array($packagexml1), '', $where)) {
+ return $packager->raiseError(
+ 'PEAR_Packagefile_v2::toTgz(): adding package.xml failed');
+ }
+ }
+
+ return $dest_package;
+ }
+ }
+
+ function toPackageFile($where = null, $state = PEAR_VALIDATE_NORMAL, $name = 'package.xml')
+ {
+ if (!$this->_packagefile->validate($state)) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toPackageFile: invalid package.xml',
+ null, null, null, $this->_packagefile->getValidationWarnings());
+ }
+
+ if ($where === null) {
+ if (!($where = System::mktemp(array('-d')))) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toPackageFile: mktemp failed');
+ }
+ } elseif (!@System::mkDir(array('-p', $where))) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toPackageFile: "' . $where . '" could' .
+ ' not be created');
+ }
+
+ $newpkgfile = $where . DIRECTORY_SEPARATOR . $name;
+ $np = @fopen($newpkgfile, 'wb');
+ if (!$np) {
+ return PEAR::raiseError('PEAR_Packagefile_v2::toPackageFile: unable to save ' .
+ "$name as $newpkgfile");
+ }
+ fwrite($np, $this->toXml($state));
+ fclose($np);
+ return $newpkgfile;
+ }
+
+ function &toV2()
+ {
+ return $this->_packagefile;
+ }
+
+ /**
+ * Return an XML document based on the package info (as returned
+ * by the PEAR_Common::infoFrom* methods).
+ *
+ * @return string XML data
+ */
+ function toXml($state = PEAR_VALIDATE_NORMAL, $options = array())
+ {
+ $this->_packagefile->setDate(date('Y-m-d'));
+ $this->_packagefile->setTime(date('H:i:s'));
+ if (!$this->_packagefile->validate($state)) {
+ return false;
+ }
+
+ if (is_array($options)) {
+ $this->options = array_merge($this->_defaultOptions, $options);
+ } else {
+ $this->options = $this->_defaultOptions;
+ }
+
+ $arr = $this->_packagefile->getArray();
+ if (isset($arr['filelist'])) {
+ unset($arr['filelist']);
+ }
+
+ if (isset($arr['_lastversion'])) {
+ unset($arr['_lastversion']);
+ }
+
+ // Fix the notes a little bit
+ if (isset($arr['notes'])) {
+ // This trims out the indenting, needs fixing
+ $arr['notes'] = "\n" . trim($arr['notes']) . "\n";
+ }
+
+ if (isset($arr['changelog']) && !empty($arr['changelog'])) {
+ // Fix for inconsistency how the array is filled depending on the changelog release amount
+ if (!isset($arr['changelog']['release'][0])) {
+ $release = $arr['changelog']['release'];
+ unset($arr['changelog']['release']);
+
+ $arr['changelog']['release'] = array();
+ $arr['changelog']['release'][0] = $release;
+ }
+
+ foreach (array_keys($arr['changelog']['release']) as $key) {
+ $c =& $arr['changelog']['release'][$key];
+ if (isset($c['notes'])) {
+ // This trims out the indenting, needs fixing
+ $c['notes'] = "\n" . trim($c['notes']) . "\n";
+ }
+ }
+ }
+
+ if ($state ^ PEAR_VALIDATE_PACKAGING && !isset($arr['bundle'])) {
+ $use = $this->_recursiveXmlFilelist($arr['contents']['dir']['file']);
+ unset($arr['contents']['dir']['file']);
+ if (isset($use['dir'])) {
+ $arr['contents']['dir']['dir'] = $use['dir'];
+ }
+ if (isset($use['file'])) {
+ $arr['contents']['dir']['file'] = $use['file'];
+ }
+ $this->options['beautifyFilelist'] = true;
+ }
+
+ $arr['attribs']['packagerversion'] = '1.10.1';
+ if ($this->serialize($arr, $options)) {
+ return $this->_serializedData . "\n";
+ }
+
+ return false;
+ }
+
+
+ function _recursiveXmlFilelist($list)
+ {
+ $dirs = array();
+ if (isset($list['attribs'])) {
+ $file = $list['attribs']['name'];
+ unset($list['attribs']['name']);
+ $attributes = $list['attribs'];
+ $this->_addDir($dirs, explode('/', dirname($file)), $file, $attributes);
+ } else {
+ foreach ($list as $a) {
+ $file = $a['attribs']['name'];
+ $attributes = $a['attribs'];
+ unset($a['attribs']);
+ $this->_addDir($dirs, explode('/', dirname($file)), $file, $attributes, $a);
+ }
+ }
+ $this->_formatDir($dirs);
+ $this->_deFormat($dirs);
+ return $dirs;
+ }
+
+ function _addDir(&$dirs, $dir, $file = null, $attributes = null, $tasks = null)
+ {
+ if (!$tasks) {
+ $tasks = array();
+ }
+ if ($dir == array() || $dir == array('.')) {
+ $dirs['file'][basename($file)] = $tasks;
+ $attributes['name'] = basename($file);
+ $dirs['file'][basename($file)]['attribs'] = $attributes;
+ return;
+ }
+ $curdir = array_shift($dir);
+ if (!isset($dirs['dir'][$curdir])) {
+ $dirs['dir'][$curdir] = array();
+ }
+ $this->_addDir($dirs['dir'][$curdir], $dir, $file, $attributes, $tasks);
+ }
+
+ function _formatDir(&$dirs)
+ {
+ if (!count($dirs)) {
+ return array();
+ }
+ $newdirs = array();
+ if (isset($dirs['dir'])) {
+ $newdirs['dir'] = $dirs['dir'];
+ }
+ if (isset($dirs['file'])) {
+ $newdirs['file'] = $dirs['file'];
+ }
+ $dirs = $newdirs;
+ if (isset($dirs['dir'])) {
+ uksort($dirs['dir'], 'strnatcasecmp');
+ foreach ($dirs['dir'] as $dir => $contents) {
+ $this->_formatDir($dirs['dir'][$dir]);
+ }
+ }
+ if (isset($dirs['file'])) {
+ uksort($dirs['file'], 'strnatcasecmp');
+ };
+ }
+
+ function _deFormat(&$dirs)
+ {
+ if (!count($dirs)) {
+ return array();
+ }
+ $newdirs = array();
+ if (isset($dirs['dir'])) {
+ foreach ($dirs['dir'] as $dir => $contents) {
+ $newdir = array();
+ $newdir['attribs']['name'] = $dir;
+ $this->_deFormat($contents);
+ foreach ($contents as $tag => $val) {
+ $newdir[$tag] = $val;
+ }
+ $newdirs['dir'][] = $newdir;
+ }
+ if (count($newdirs['dir']) == 1) {
+ $newdirs['dir'] = $newdirs['dir'][0];
+ }
+ }
+ if (isset($dirs['file'])) {
+ foreach ($dirs['file'] as $name => $file) {
+ $newdirs['file'][] = $file;
+ }
+ if (count($newdirs['file']) == 1) {
+ $newdirs['file'] = $newdirs['file'][0];
+ }
+ }
+ $dirs = $newdirs;
+ }
+
+ /**
+ * reset all options to default options
+ *
+ * @access public
+ * @see setOption(), XML_Unserializer()
+ */
+ function resetOptions()
+ {
+ $this->options = $this->_defaultOptions;
+ }
+
+ /**
+ * set an option
+ *
+ * You can use this method if you do not want to set all options in the constructor
+ *
+ * @access public
+ * @see resetOption(), XML_Serializer()
+ */
+ function setOption($name, $value)
+ {
+ $this->options[$name] = $value;
+ }
+
+ /**
+ * sets several options at once
+ *
+ * You can use this method if you do not want to set all options in the constructor
+ *
+ * @access public
+ * @see resetOption(), XML_Unserializer(), setOption()
+ */
+ function setOptions($options)
+ {
+ $this->options = array_merge($this->options, $options);
+ }
+
+ /**
+ * serialize data
+ *
+ * @access public
+ * @param mixed $data data to serialize
+ * @return boolean true on success, pear error on failure
+ */
+ function serialize($data, $options = null)
+ {
+ // if options have been specified, use them instead
+ // of the previously defined ones
+ if (is_array($options)) {
+ $optionsBak = $this->options;
+ if (isset($options['overrideOptions']) && $options['overrideOptions'] == true) {
+ $this->options = array_merge($this->_defaultOptions, $options);
+ } else {
+ $this->options = array_merge($this->options, $options);
+ }
+ } else {
+ $optionsBak = null;
+ }
+
+ // start depth is zero
+ $this->_tagDepth = 0;
+ $this->_serializedData = '';
+ // serialize an array
+ if (is_array($data)) {
+ $tagName = isset($this->options['rootName']) ? $this->options['rootName'] : 'array';
+ $this->_serializedData .= $this->_serializeArray($data, $tagName, $this->options['rootAttributes']);
+ }
+
+ // add doctype declaration
+ if ($this->options['addDoctype'] === true) {
+ $this->_serializedData = XML_Util::getDoctypeDeclaration($tagName, $this->options['doctype'])
+ . $this->options['linebreak']
+ . $this->_serializedData;
+ }
+
+ // build xml declaration
+ if ($this->options['addDecl']) {
+ $atts = array();
+ $encoding = isset($this->options['encoding']) ? $this->options['encoding'] : null;
+ $this->_serializedData = XML_Util::getXMLDeclaration('1.0', $encoding)
+ . $this->options['linebreak']
+ . $this->_serializedData;
+ }
+
+
+ if ($optionsBak !== null) {
+ $this->options = $optionsBak;
+ }
+
+ return true;
+ }
+
+ /**
+ * get the result of the serialization
+ *
+ * @access public
+ * @return string serialized XML
+ */
+ function getSerializedData()
+ {
+ if ($this->_serializedData === null) {
+ return $this->raiseError('No serialized data available. Use XML_Serializer::serialize() first.', XML_SERIALIZER_ERROR_NO_SERIALIZATION);
+ }
+ return $this->_serializedData;
+ }
+
+ /**
+ * serialize any value
+ *
+ * This method checks for the type of the value and calls the appropriate method
+ *
+ * @access private
+ * @param mixed $value
+ * @param string $tagName
+ * @param array $attributes
+ * @return string
+ */
+ function _serializeValue($value, $tagName = null, $attributes = array())
+ {
+ if (is_array($value)) {
+ $xml = $this->_serializeArray($value, $tagName, $attributes);
+ } elseif (is_object($value)) {
+ $xml = $this->_serializeObject($value, $tagName);
+ } else {
+ $tag = array(
+ 'qname' => $tagName,
+ 'attributes' => $attributes,
+ 'content' => $value
+ );
+ $xml = $this->_createXMLTag($tag);
+ }
+ return $xml;
+ }
+
+ /**
+ * serialize an array
+ *
+ * @access private
+ * @param array $array array to serialize
+ * @param string $tagName name of the root tag
+ * @param array $attributes attributes for the root tag
+ * @return string $string serialized data
+ * @uses XML_Util::isValidName() to check, whether key has to be substituted
+ */
+ function _serializeArray(&$array, $tagName = null, $attributes = array())
+ {
+ $_content = null;
+
+ /**
+ * check for special attributes
+ */
+ if ($this->options['attributesArray'] !== null) {
+ if (isset($array[$this->options['attributesArray']])) {
+ $attributes = $array[$this->options['attributesArray']];
+ unset($array[$this->options['attributesArray']]);
+ }
+ /**
+ * check for special content
+ */
+ if ($this->options['contentName'] !== null) {
+ if (isset($array[$this->options['contentName']])) {
+ $_content = $array[$this->options['contentName']];
+ unset($array[$this->options['contentName']]);
+ }
+ }
+ }
+
+ /*
+ * if mode is set to simpleXML, check whether
+ * the array is associative or indexed
+ */
+ if (is_array($array) && $this->options['mode'] == 'simplexml') {
+ $indexed = true;
+ if (!count($array)) {
+ $indexed = false;
+ }
+ foreach ($array as $key => $val) {
+ if (!is_int($key)) {
+ $indexed = false;
+ break;
+ }
+ }
+
+ if ($indexed && $this->options['mode'] == 'simplexml') {
+ $string = '';
+ foreach ($array as $key => $val) {
+ if ($this->options['beautifyFilelist'] && $tagName == 'dir') {
+ if (!isset($this->_curdir)) {
+ $this->_curdir = '';
+ }
+ $savedir = $this->_curdir;
+ if (isset($val['attribs'])) {
+ if ($val['attribs']['name'] == '/') {
+ $this->_curdir = '/';
+ } else {
+ if ($this->_curdir == '/') {
+ $this->_curdir = '';
+ }
+ $this->_curdir .= '/' . $val['attribs']['name'];
+ }
+ }
+ }
+ $string .= $this->_serializeValue( $val, $tagName, $attributes);
+ if ($this->options['beautifyFilelist'] && $tagName == 'dir') {
+ $string .= ' ';
+ if (empty($savedir)) {
+ unset($this->_curdir);
+ } else {
+ $this->_curdir = $savedir;
+ }
+ }
+
+ $string .= $this->options['linebreak'];
+ // do indentation
+ if ($this->options['indent'] !== null && $this->_tagDepth > 0) {
+ $string .= str_repeat($this->options['indent'], $this->_tagDepth);
+ }
+ }
+ return rtrim($string);
+ }
+ }
+
+ if ($this->options['scalarAsAttributes'] === true) {
+ foreach ($array as $key => $value) {
+ if (is_scalar($value) && (XML_Util::isValidName($key) === true)) {
+ unset($array[$key]);
+ $attributes[$this->options['prependAttributes'].$key] = $value;
+ }
+ }
+ }
+
+ // check for empty array => create empty tag
+ if (empty($array)) {
+ $tag = array(
+ 'qname' => $tagName,
+ 'content' => $_content,
+ 'attributes' => $attributes
+ );
+
+ } else {
+ $this->_tagDepth++;
+ $tmp = $this->options['linebreak'];
+ foreach ($array as $key => $value) {
+ // do indentation
+ if ($this->options['indent'] !== null && $this->_tagDepth > 0) {
+ $tmp .= str_repeat($this->options['indent'], $this->_tagDepth);
+ }
+
+ // copy key
+ $origKey = $key;
+ // key cannot be used as tagname => use default tag
+ $valid = XML_Util::isValidName($key);
+ if (PEAR::isError($valid)) {
+ if ($this->options['classAsTagName'] && is_object($value)) {
+ $key = get_class($value);
+ } else {
+ $key = $this->options['defaultTagName'];
+ }
+ }
+ $atts = array();
+ if ($this->options['typeHints'] === true) {
+ $atts[$this->options['typeAttribute']] = gettype($value);
+ if ($key !== $origKey) {
+ $atts[$this->options['keyAttribute']] = (string)$origKey;
+ }
+
+ }
+ if ($this->options['beautifyFilelist'] && $key == 'dir') {
+ if (!isset($this->_curdir)) {
+ $this->_curdir = '';
+ }
+ $savedir = $this->_curdir;
+ if (isset($value['attribs'])) {
+ if ($value['attribs']['name'] == '/') {
+ $this->_curdir = '/';
+ } else {
+ $this->_curdir .= '/' . $value['attribs']['name'];
+ }
+ }
+ }
+
+ if (is_string($value) && $value && ($value{strlen($value) - 1} == "\n")) {
+ $value .= str_repeat($this->options['indent'], $this->_tagDepth);
+ }
+ $tmp .= $this->_createXMLTag(array(
+ 'qname' => $key,
+ 'attributes' => $atts,
+ 'content' => $value )
+ );
+ if ($this->options['beautifyFilelist'] && $key == 'dir') {
+ if (isset($value['attribs'])) {
+ $tmp .= ' ';
+ if (empty($savedir)) {
+ unset($this->_curdir);
+ } else {
+ $this->_curdir = $savedir;
+ }
+ }
+ }
+ $tmp .= $this->options['linebreak'];
+ }
+
+ $this->_tagDepth--;
+ if ($this->options['indent']!==null && $this->_tagDepth>0) {
+ $tmp .= str_repeat($this->options['indent'], $this->_tagDepth);
+ }
+
+ if (trim($tmp) === '') {
+ $tmp = null;
+ }
+
+ $tag = array(
+ 'qname' => $tagName,
+ 'content' => $tmp,
+ 'attributes' => $attributes
+ );
+ }
+ if ($this->options['typeHints'] === true) {
+ if (!isset($tag['attributes'][$this->options['typeAttribute']])) {
+ $tag['attributes'][$this->options['typeAttribute']] = 'array';
+ }
+ }
+
+ $string = $this->_createXMLTag($tag, false);
+ return $string;
+ }
+
+ /**
+ * create a tag from an array
+ * this method awaits an array in the following format
+ * array(
+ * 'qname' => $tagName,
+ * 'attributes' => array(),
+ * 'content' => $content, // optional
+ * 'namespace' => $namespace // optional
+ * 'namespaceUri' => $namespaceUri // optional
+ * )
+ *
+ * @access private
+ * @param array $tag tag definition
+ * @param boolean $replaceEntities whether to replace XML entities in content or not
+ * @return string $string XML tag
+ */
+ function _createXMLTag($tag, $replaceEntities = true)
+ {
+ if ($this->options['indentAttributes'] !== false) {
+ $multiline = true;
+ $indent = str_repeat($this->options['indent'], $this->_tagDepth);
+
+ if ($this->options['indentAttributes'] == '_auto') {
+ $indent .= str_repeat(' ', (strlen($tag['qname'])+2));
+
+ } else {
+ $indent .= $this->options['indentAttributes'];
+ }
+ } else {
+ $indent = $multiline = false;
+ }
+
+ if (is_array($tag['content'])) {
+ if (empty($tag['content'])) {
+ $tag['content'] = '';
+ }
+ } elseif(is_scalar($tag['content']) && (string)$tag['content'] == '') {
+ $tag['content'] = '';
+ }
+
+ if (is_scalar($tag['content']) || is_null($tag['content'])) {
+ if ($replaceEntities === true) {
+ $replaceEntities = XML_UTIL_ENTITIES_XML;
+ }
+
+ $tag = XML_Util::createTagFromArray($tag, $replaceEntities, $multiline, $indent, $this->options['linebreak']);
+ } elseif (is_array($tag['content'])) {
+ $tag = $this->_serializeArray($tag['content'], $tag['qname'], $tag['attributes']);
+ } elseif (is_object($tag['content'])) {
+ $tag = $this->_serializeObject($tag['content'], $tag['qname'], $tag['attributes']);
+ } elseif (is_resource($tag['content'])) {
+ settype($tag['content'], 'string');
+ $tag = XML_Util::createTagFromArray($tag, $replaceEntities);
+ }
+ return $tag;
+ }
+}
+ PEAR-1.10.1/PEAR/PackageFile/Parser/v1.php 0000644 0001750 0000144 00000040207 12610427352 017054 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+/**
+ * package.xml abstraction class
+ */
+require_once 'PEAR/PackageFile/v1.php';
+/**
+ * Parser for package.xml version 1.0
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: @PEAR-VER@
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_PackageFile_Parser_v1
+{
+ var $_registry;
+ var $_config;
+ var $_logger;
+ /**
+ * BC hack to allow PEAR_Common::infoFromString() to sort of
+ * work with the version 2.0 format - there's no filelist though
+ * @param PEAR_PackageFile_v2
+ */
+ function fromV2($packagefile)
+ {
+ $info = $packagefile->getArray(true);
+ $ret = new PEAR_PackageFile_v1;
+ $ret->fromArray($info['old']);
+ }
+
+ function setConfig(&$c)
+ {
+ $this->_config = &$c;
+ $this->_registry = &$c->getRegistry();
+ }
+
+ function setLogger(&$l)
+ {
+ $this->_logger = &$l;
+ }
+
+ /**
+ * @param string contents of package.xml file, version 1.0
+ * @return bool success of parsing
+ */
+ function &parse($data, $file, $archive = false)
+ {
+ if (!extension_loaded('xml')) {
+ return PEAR::raiseError('Cannot create xml parser for parsing package.xml, no xml extension');
+ }
+ $xp = xml_parser_create();
+ if (!$xp) {
+ $a = &PEAR::raiseError('Cannot create xml parser for parsing package.xml');
+ return $a;
+ }
+ xml_set_object($xp, $this);
+ xml_set_element_handler($xp, '_element_start_1_0', '_element_end_1_0');
+ xml_set_character_data_handler($xp, '_pkginfo_cdata_1_0');
+ xml_parser_set_option($xp, XML_OPTION_CASE_FOLDING, false);
+
+ $this->element_stack = array();
+ $this->_packageInfo = array('provides' => array());
+ $this->current_element = false;
+ unset($this->dir_install);
+ $this->_packageInfo['filelist'] = array();
+ $this->filelist =& $this->_packageInfo['filelist'];
+ $this->dir_names = array();
+ $this->in_changelog = false;
+ $this->d_i = 0;
+ $this->cdata = '';
+ $this->_isValid = true;
+
+ if (!xml_parse($xp, $data, 1)) {
+ $code = xml_get_error_code($xp);
+ $line = xml_get_current_line_number($xp);
+ xml_parser_free($xp);
+ $a = PEAR::raiseError(sprintf("XML error: %s at line %d",
+ $str = xml_error_string($code), $line), 2);
+ return $a;
+ }
+
+ xml_parser_free($xp);
+
+ $pf = new PEAR_PackageFile_v1;
+ $pf->setConfig($this->_config);
+ if (isset($this->_logger)) {
+ $pf->setLogger($this->_logger);
+ }
+ $pf->setPackagefile($file, $archive);
+ $pf->fromArray($this->_packageInfo);
+ return $pf;
+ }
+ // {{{ _unIndent()
+
+ /**
+ * Unindent given string
+ *
+ * @param string $str The string that has to be unindented.
+ * @return string
+ * @access private
+ */
+ function _unIndent($str)
+ {
+ // remove leading newlines
+ $str = preg_replace('/^[\r\n]+/', '', $str);
+ // find whitespace at the beginning of the first line
+ $indent_len = strspn($str, " \t");
+ $indent = substr($str, 0, $indent_len);
+ $data = '';
+ // remove the same amount of whitespace from following lines
+ foreach (explode("\n", $str) as $line) {
+ if (substr($line, 0, $indent_len) == $indent) {
+ $data .= substr($line, $indent_len) . "\n";
+ } elseif (trim(substr($line, 0, $indent_len))) {
+ $data .= ltrim($line);
+ }
+ }
+ return $data;
+ }
+
+ // Support for package DTD v1.0:
+ // {{{ _element_start_1_0()
+
+ /**
+ * XML parser callback for ending elements. Used for version 1.0
+ * packages.
+ *
+ * @param resource $xp XML parser resource
+ * @param string $name name of ending element
+ *
+ * @return void
+ *
+ * @access private
+ */
+ function _element_start_1_0($xp, $name, $attribs)
+ {
+ array_push($this->element_stack, $name);
+ $this->current_element = $name;
+ $spos = sizeof($this->element_stack) - 2;
+ $this->prev_element = ($spos >= 0) ? $this->element_stack[$spos] : '';
+ $this->current_attributes = $attribs;
+ $this->cdata = '';
+ switch ($name) {
+ case 'dir':
+ if ($this->in_changelog) {
+ break;
+ }
+ if (array_key_exists('name', $attribs) && $attribs['name'] != '/') {
+ $attribs['name'] = preg_replace(array('!\\\\+!', '!/+!'), array('/', '/'),
+ $attribs['name']);
+ if (strrpos($attribs['name'], '/') === strlen($attribs['name']) - 1) {
+ $attribs['name'] = substr($attribs['name'], 0,
+ strlen($attribs['name']) - 1);
+ }
+ if (strpos($attribs['name'], '/') === 0) {
+ $attribs['name'] = substr($attribs['name'], 1);
+ }
+ $this->dir_names[] = $attribs['name'];
+ }
+ if (isset($attribs['baseinstalldir'])) {
+ $this->dir_install = $attribs['baseinstalldir'];
+ }
+ if (isset($attribs['role'])) {
+ $this->dir_role = $attribs['role'];
+ }
+ break;
+ case 'file':
+ if ($this->in_changelog) {
+ break;
+ }
+ if (isset($attribs['name'])) {
+ $path = '';
+ if (count($this->dir_names)) {
+ foreach ($this->dir_names as $dir) {
+ $path .= $dir . '/';
+ }
+ }
+ $path .= preg_replace(array('!\\\\+!', '!/+!'), array('/', '/'),
+ $attribs['name']);
+ unset($attribs['name']);
+ $this->current_path = $path;
+ $this->filelist[$path] = $attribs;
+ // Set the baseinstalldir only if the file don't have this attrib
+ if (!isset($this->filelist[$path]['baseinstalldir']) &&
+ isset($this->dir_install))
+ {
+ $this->filelist[$path]['baseinstalldir'] = $this->dir_install;
+ }
+ // Set the Role
+ if (!isset($this->filelist[$path]['role']) && isset($this->dir_role)) {
+ $this->filelist[$path]['role'] = $this->dir_role;
+ }
+ }
+ break;
+ case 'replace':
+ if (!$this->in_changelog) {
+ $this->filelist[$this->current_path]['replacements'][] = $attribs;
+ }
+ break;
+ case 'maintainers':
+ $this->_packageInfo['maintainers'] = array();
+ $this->m_i = 0; // maintainers array index
+ break;
+ case 'maintainer':
+ // compatibility check
+ if (!isset($this->_packageInfo['maintainers'])) {
+ $this->_packageInfo['maintainers'] = array();
+ $this->m_i = 0;
+ }
+ $this->_packageInfo['maintainers'][$this->m_i] = array();
+ $this->current_maintainer =& $this->_packageInfo['maintainers'][$this->m_i];
+ break;
+ case 'changelog':
+ $this->_packageInfo['changelog'] = array();
+ $this->c_i = 0; // changelog array index
+ $this->in_changelog = true;
+ break;
+ case 'release':
+ if ($this->in_changelog) {
+ $this->_packageInfo['changelog'][$this->c_i] = array();
+ $this->current_release = &$this->_packageInfo['changelog'][$this->c_i];
+ } else {
+ $this->current_release = &$this->_packageInfo;
+ }
+ break;
+ case 'deps':
+ if (!$this->in_changelog) {
+ $this->_packageInfo['release_deps'] = array();
+ }
+ break;
+ case 'dep':
+ // dependencies array index
+ if (!$this->in_changelog) {
+ $this->d_i++;
+ isset($attribs['type']) ? ($attribs['type'] = strtolower($attribs['type'])) : false;
+ $this->_packageInfo['release_deps'][$this->d_i] = $attribs;
+ }
+ break;
+ case 'configureoptions':
+ if (!$this->in_changelog) {
+ $this->_packageInfo['configure_options'] = array();
+ }
+ break;
+ case 'configureoption':
+ if (!$this->in_changelog) {
+ $this->_packageInfo['configure_options'][] = $attribs;
+ }
+ break;
+ case 'provides':
+ if (empty($attribs['type']) || empty($attribs['name'])) {
+ break;
+ }
+ $attribs['explicit'] = true;
+ $this->_packageInfo['provides']["$attribs[type];$attribs[name]"] = $attribs;
+ break;
+ case 'package' :
+ if (isset($attribs['version'])) {
+ $this->_packageInfo['xsdversion'] = trim($attribs['version']);
+ } else {
+ $this->_packageInfo['xsdversion'] = '1.0';
+ }
+ if (isset($attribs['packagerversion'])) {
+ $this->_packageInfo['packagerversion'] = $attribs['packagerversion'];
+ }
+ break;
+ }
+ }
+
+ // }}}
+ // {{{ _element_end_1_0()
+
+ /**
+ * XML parser callback for ending elements. Used for version 1.0
+ * packages.
+ *
+ * @param resource $xp XML parser resource
+ * @param string $name name of ending element
+ *
+ * @return void
+ *
+ * @access private
+ */
+ function _element_end_1_0($xp, $name)
+ {
+ $data = trim($this->cdata);
+ switch ($name) {
+ case 'name':
+ switch ($this->prev_element) {
+ case 'package':
+ $this->_packageInfo['package'] = $data;
+ break;
+ case 'maintainer':
+ $this->current_maintainer['name'] = $data;
+ break;
+ }
+ break;
+ case 'extends' :
+ $this->_packageInfo['extends'] = $data;
+ break;
+ case 'summary':
+ $this->_packageInfo['summary'] = $data;
+ break;
+ case 'description':
+ $data = $this->_unIndent($this->cdata);
+ $this->_packageInfo['description'] = $data;
+ break;
+ case 'user':
+ $this->current_maintainer['handle'] = $data;
+ break;
+ case 'email':
+ $this->current_maintainer['email'] = $data;
+ break;
+ case 'role':
+ $this->current_maintainer['role'] = $data;
+ break;
+ case 'version':
+ if ($this->in_changelog) {
+ $this->current_release['version'] = $data;
+ } else {
+ $this->_packageInfo['version'] = $data;
+ }
+ break;
+ case 'date':
+ if ($this->in_changelog) {
+ $this->current_release['release_date'] = $data;
+ } else {
+ $this->_packageInfo['release_date'] = $data;
+ }
+ break;
+ case 'notes':
+ // try to "de-indent" release notes in case someone
+ // has been over-indenting their xml ;-)
+ // Trim only on the right side
+ $data = rtrim($this->_unIndent($this->cdata));
+ if ($this->in_changelog) {
+ $this->current_release['release_notes'] = $data;
+ } else {
+ $this->_packageInfo['release_notes'] = $data;
+ }
+ break;
+ case 'warnings':
+ if ($this->in_changelog) {
+ $this->current_release['release_warnings'] = $data;
+ } else {
+ $this->_packageInfo['release_warnings'] = $data;
+ }
+ break;
+ case 'state':
+ if ($this->in_changelog) {
+ $this->current_release['release_state'] = $data;
+ } else {
+ $this->_packageInfo['release_state'] = $data;
+ }
+ break;
+ case 'license':
+ if ($this->in_changelog) {
+ $this->current_release['release_license'] = $data;
+ } else {
+ $this->_packageInfo['release_license'] = $data;
+ }
+ break;
+ case 'dep':
+ if ($data && !$this->in_changelog) {
+ $this->_packageInfo['release_deps'][$this->d_i]['name'] = $data;
+ }
+ break;
+ case 'dir':
+ if ($this->in_changelog) {
+ break;
+ }
+ array_pop($this->dir_names);
+ break;
+ case 'file':
+ if ($this->in_changelog) {
+ break;
+ }
+ if ($data) {
+ $path = '';
+ if (count($this->dir_names)) {
+ foreach ($this->dir_names as $dir) {
+ $path .= $dir . '/';
+ }
+ }
+ $path .= $data;
+ $this->filelist[$path] = $this->current_attributes;
+ // Set the baseinstalldir only if the file don't have this attrib
+ if (!isset($this->filelist[$path]['baseinstalldir']) &&
+ isset($this->dir_install))
+ {
+ $this->filelist[$path]['baseinstalldir'] = $this->dir_install;
+ }
+ // Set the Role
+ if (!isset($this->filelist[$path]['role']) && isset($this->dir_role)) {
+ $this->filelist[$path]['role'] = $this->dir_role;
+ }
+ }
+ break;
+ case 'maintainer':
+ if (empty($this->_packageInfo['maintainers'][$this->m_i]['role'])) {
+ $this->_packageInfo['maintainers'][$this->m_i]['role'] = 'lead';
+ }
+ $this->m_i++;
+ break;
+ case 'release':
+ if ($this->in_changelog) {
+ $this->c_i++;
+ }
+ break;
+ case 'changelog':
+ $this->in_changelog = false;
+ break;
+ }
+ array_pop($this->element_stack);
+ $spos = sizeof($this->element_stack) - 1;
+ $this->current_element = ($spos > 0) ? $this->element_stack[$spos] : '';
+ $this->cdata = '';
+ }
+
+ // }}}
+ // {{{ _pkginfo_cdata_1_0()
+
+ /**
+ * XML parser callback for character data. Used for version 1.0
+ * packages.
+ *
+ * @param resource $xp XML parser resource
+ * @param string $name character data
+ *
+ * @return void
+ *
+ * @access private
+ */
+ function _pkginfo_cdata_1_0($xp, $data)
+ {
+ if (isset($this->cdata)) {
+ $this->cdata .= $data;
+ }
+ }
+
+ // }}}
+}
+?> PEAR-1.10.1/PEAR/PackageFile/Parser/v2.php 0000644 0001750 0000144 00000006110 12610427352 017050 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a1
+ */
+/**
+ * base xml parser class
+ */
+require_once 'PEAR/XMLParser.php';
+require_once 'PEAR/PackageFile/v2.php';
+/**
+ * Parser for package.xml version 2.0
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: @PEAR-VER@
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a1
+ */
+class PEAR_PackageFile_Parser_v2 extends PEAR_XMLParser
+{
+ var $_config;
+ var $_logger;
+ var $_registry;
+
+ function setConfig(&$c)
+ {
+ $this->_config = &$c;
+ $this->_registry = &$c->getRegistry();
+ }
+
+ function setLogger(&$l)
+ {
+ $this->_logger = &$l;
+ }
+ /**
+ * Unindent given string
+ *
+ * @param string $str The string that has to be unindented.
+ * @return string
+ * @access private
+ */
+ function _unIndent($str)
+ {
+ // remove leading newlines
+ $str = preg_replace('/^[\r\n]+/', '', $str);
+ // find whitespace at the beginning of the first line
+ $indent_len = strspn($str, " \t");
+ $indent = substr($str, 0, $indent_len);
+ $data = '';
+ // remove the same amount of whitespace from following lines
+ foreach (explode("\n", $str) as $line) {
+ if (substr($line, 0, $indent_len) == $indent) {
+ $data .= substr($line, $indent_len) . "\n";
+ } else {
+ $data .= $line . "\n";
+ }
+ }
+ return $data;
+ }
+
+ /**
+ * post-process data
+ *
+ * @param string $data
+ * @param string $element element name
+ */
+ function postProcess($data, $element)
+ {
+ if ($element == 'notes') {
+ return trim($this->_unIndent($data));
+ }
+ return trim($data);
+ }
+
+ /**
+ * @param string
+ * @param string file name of the package.xml
+ * @param string|false name of the archive this package.xml came from, if any
+ * @param string class name to instantiate and return. This must be PEAR_PackageFile_v2 or
+ * a subclass
+ * @return PEAR_PackageFile_v2
+ */
+ function parse($data, $file = null, $archive = false, $class = 'PEAR_PackageFile_v2')
+ {
+ if (PEAR::isError($err = parent::parse($data))) {
+ return $err;
+ }
+
+ $ret = new $class;
+ $ret->encoding = $this->encoding;
+ $ret->setConfig($this->_config);
+ if (isset($this->_logger)) {
+ $ret->setLogger($this->_logger);
+ }
+
+ $ret->fromArray($this->_unserializedData);
+ $ret->setPackagefile($file, $archive);
+ return $ret;
+ }
+} PEAR-1.10.1/PEAR/PackageFile/v2/rw.php 0000644 0001750 0000144 00000173136 12610427352 016261 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a8
+ */
+/**
+ * For base class
+ */
+require_once 'PEAR/PackageFile/v2.php';
+/**
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a8
+ */
+class PEAR_PackageFile_v2_rw extends PEAR_PackageFile_v2
+{
+ /**
+ * @param string Extension name
+ * @return bool success of operation
+ */
+ function setProvidesExtension($extension)
+ {
+ if (in_array($this->getPackageType(),
+ array('extsrc', 'extbin', 'zendextsrc', 'zendextbin'))) {
+ if (!isset($this->_packageInfo['providesextension'])) {
+ // ensure that the channel tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('usesrole', 'usestask', 'srcpackage', 'srcuri', 'phprelease',
+ 'extsrcrelease', 'extbinrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'bundle', 'changelog'),
+ $extension, 'providesextension');
+ }
+ $this->_packageInfo['providesextension'] = $extension;
+ return true;
+ }
+ return false;
+ }
+
+ function setPackage($package)
+ {
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['attribs'])) {
+ $this->_packageInfo = array_merge(array('attribs' => array(
+ 'version' => '2.0',
+ 'xmlns' => 'http://pear.php.net/dtd/package-2.0',
+ 'xmlns:tasks' => 'http://pear.php.net/dtd/tasks-1.0',
+ 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+ 'xsi:schemaLocation' => 'http://pear.php.net/dtd/tasks-1.0
+ http://pear.php.net/dtd/tasks-1.0.xsd
+ http://pear.php.net/dtd/package-2.0
+ http://pear.php.net/dtd/package-2.0.xsd',
+ )), $this->_packageInfo);
+ }
+ if (!isset($this->_packageInfo['name'])) {
+ return $this->_packageInfo = array_merge(array('name' => $package),
+ $this->_packageInfo);
+ }
+ $this->_packageInfo['name'] = $package;
+ }
+
+ /**
+ * set this as a package.xml version 2.1
+ * @access private
+ */
+ function _setPackageVersion2_1()
+ {
+ $info = array(
+ 'version' => '2.1',
+ 'xmlns' => 'http://pear.php.net/dtd/package-2.1',
+ 'xmlns:tasks' => 'http://pear.php.net/dtd/tasks-1.0',
+ 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+ 'xsi:schemaLocation' => 'http://pear.php.net/dtd/tasks-1.0
+ http://pear.php.net/dtd/tasks-1.0.xsd
+ http://pear.php.net/dtd/package-2.1
+ http://pear.php.net/dtd/package-2.1.xsd',
+ );
+ if (!isset($this->_packageInfo['attribs'])) {
+ $this->_packageInfo = array_merge(array('attribs' => $info), $this->_packageInfo);
+ } else {
+ $this->_packageInfo['attribs'] = $info;
+ }
+ }
+
+ function setUri($uri)
+ {
+ unset($this->_packageInfo['channel']);
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['uri'])) {
+ // ensure that the uri tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('extends', 'summary', 'description', 'lead',
+ 'developer', 'contributor', 'helper', 'date', 'time', 'version',
+ 'stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'), $uri, 'uri');
+ }
+ $this->_packageInfo['uri'] = $uri;
+ }
+
+ function setChannel($channel)
+ {
+ unset($this->_packageInfo['uri']);
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['channel'])) {
+ // ensure that the channel tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('extends', 'summary', 'description', 'lead',
+ 'developer', 'contributor', 'helper', 'date', 'time', 'version',
+ 'stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'), $channel, 'channel');
+ }
+ $this->_packageInfo['channel'] = $channel;
+ }
+
+ function setExtends($extends)
+ {
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['extends'])) {
+ // ensure that the extends tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('summary', 'description', 'lead',
+ 'developer', 'contributor', 'helper', 'date', 'time', 'version',
+ 'stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'), $extends, 'extends');
+ }
+ $this->_packageInfo['extends'] = $extends;
+ }
+
+ function setSummary($summary)
+ {
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['summary'])) {
+ // ensure that the summary tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('description', 'lead',
+ 'developer', 'contributor', 'helper', 'date', 'time', 'version',
+ 'stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'), $summary, 'summary');
+ }
+ $this->_packageInfo['summary'] = $summary;
+ }
+
+ function setDescription($desc)
+ {
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['description'])) {
+ // ensure that the description tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('lead',
+ 'developer', 'contributor', 'helper', 'date', 'time', 'version',
+ 'stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'), $desc, 'description');
+ }
+ $this->_packageInfo['description'] = $desc;
+ }
+
+ /**
+ * Adds a new maintainer - no checking of duplicates is performed, use
+ * updatemaintainer for that purpose.
+ */
+ function addMaintainer($role, $handle, $name, $email, $active = 'yes')
+ {
+ if (!in_array($role, array('lead', 'developer', 'contributor', 'helper'))) {
+ return false;
+ }
+ if (isset($this->_packageInfo[$role])) {
+ if (!isset($this->_packageInfo[$role][0])) {
+ $this->_packageInfo[$role] = array($this->_packageInfo[$role]);
+ }
+ $this->_packageInfo[$role][] =
+ array(
+ 'name' => $name,
+ 'user' => $handle,
+ 'email' => $email,
+ 'active' => $active,
+ );
+ } else {
+ $testarr = array('lead',
+ 'developer', 'contributor', 'helper', 'date', 'time', 'version',
+ 'stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease',
+ 'extbinrelease', 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog');
+ foreach (array('lead', 'developer', 'contributor', 'helper') as $testrole) {
+ array_shift($testarr);
+ if ($role == $testrole) {
+ break;
+ }
+ }
+ if (!isset($this->_packageInfo[$role])) {
+ // ensure that the extends tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo, $testarr,
+ array(), $role);
+ }
+ $this->_packageInfo[$role] =
+ array(
+ 'name' => $name,
+ 'user' => $handle,
+ 'email' => $email,
+ 'active' => $active,
+ );
+ }
+ $this->_isValid = 0;
+ }
+
+ function updateMaintainer($newrole, $handle, $name, $email, $active = 'yes')
+ {
+ $found = false;
+ foreach (array('lead', 'developer', 'contributor', 'helper') as $role) {
+ if (!isset($this->_packageInfo[$role])) {
+ continue;
+ }
+ $info = $this->_packageInfo[$role];
+ if (!isset($info[0])) {
+ if ($info['user'] == $handle) {
+ $found = true;
+ break;
+ }
+ }
+ foreach ($info as $i => $maintainer) {
+ if (is_array($maintainer) && $maintainer['user'] == $handle) {
+ $found = $i;
+ break 2;
+ }
+ }
+ }
+ if ($found === false) {
+ return $this->addMaintainer($newrole, $handle, $name, $email, $active);
+ }
+ if ($found !== false) {
+ if ($found === true) {
+ unset($this->_packageInfo[$role]);
+ } else {
+ unset($this->_packageInfo[$role][$found]);
+ $this->_packageInfo[$role] = array_values($this->_packageInfo[$role]);
+ }
+ }
+ $this->addMaintainer($newrole, $handle, $name, $email, $active);
+ $this->_isValid = 0;
+ }
+
+ function deleteMaintainer($handle)
+ {
+ $found = false;
+ foreach (array('lead', 'developer', 'contributor', 'helper') as $role) {
+ if (!isset($this->_packageInfo[$role])) {
+ continue;
+ }
+ if (!isset($this->_packageInfo[$role][0])) {
+ $this->_packageInfo[$role] = array($this->_packageInfo[$role]);
+ }
+ foreach ($this->_packageInfo[$role] as $i => $maintainer) {
+ if ($maintainer['user'] == $handle) {
+ $found = $i;
+ break;
+ }
+ }
+ if ($found !== false) {
+ unset($this->_packageInfo[$role][$found]);
+ if (!count($this->_packageInfo[$role]) && $role == 'lead') {
+ $this->_isValid = 0;
+ }
+ if (!count($this->_packageInfo[$role])) {
+ unset($this->_packageInfo[$role]);
+ return true;
+ }
+ $this->_packageInfo[$role] =
+ array_values($this->_packageInfo[$role]);
+ if (count($this->_packageInfo[$role]) == 1) {
+ $this->_packageInfo[$role] = $this->_packageInfo[$role][0];
+ }
+ return true;
+ }
+ if (count($this->_packageInfo[$role]) == 1) {
+ $this->_packageInfo[$role] = $this->_packageInfo[$role][0];
+ }
+ }
+ return false;
+ }
+
+ function setReleaseVersion($version)
+ {
+ if (isset($this->_packageInfo['version']) &&
+ isset($this->_packageInfo['version']['release'])) {
+ unset($this->_packageInfo['version']['release']);
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $version, array(
+ 'version' => array('stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'),
+ 'release' => array('api')));
+ $this->_isValid = 0;
+ }
+
+ function setAPIVersion($version)
+ {
+ if (isset($this->_packageInfo['version']) &&
+ isset($this->_packageInfo['version']['api'])) {
+ unset($this->_packageInfo['version']['api']);
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $version, array(
+ 'version' => array('stability', 'license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'),
+ 'api' => array()));
+ $this->_isValid = 0;
+ }
+
+ /**
+ * snapshot|devel|alpha|beta|stable
+ */
+ function setReleaseStability($state)
+ {
+ if (isset($this->_packageInfo['stability']) &&
+ isset($this->_packageInfo['stability']['release'])) {
+ unset($this->_packageInfo['stability']['release']);
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $state, array(
+ 'stability' => array('license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'),
+ 'release' => array('api')));
+ $this->_isValid = 0;
+ }
+
+ /**
+ * @param devel|alpha|beta|stable
+ */
+ function setAPIStability($state)
+ {
+ if (isset($this->_packageInfo['stability']) &&
+ isset($this->_packageInfo['stability']['api'])) {
+ unset($this->_packageInfo['stability']['api']);
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $state, array(
+ 'stability' => array('license', 'notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'),
+ 'api' => array()));
+ $this->_isValid = 0;
+ }
+
+ function setLicense($license, $uri = false, $filesource = false)
+ {
+ if (!isset($this->_packageInfo['license'])) {
+ // ensure that the license tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('notes', 'contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'), 0, 'license');
+ }
+ if ($uri || $filesource) {
+ $attribs = array();
+ if ($uri) {
+ $attribs['uri'] = $uri;
+ }
+ $uri = true; // for test below
+ if ($filesource) {
+ $attribs['filesource'] = $filesource;
+ }
+ }
+ $license = $uri ? array('attribs' => $attribs, '_content' => $license) : $license;
+ $this->_packageInfo['license'] = $license;
+ $this->_isValid = 0;
+ }
+
+ function setNotes($notes)
+ {
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['notes'])) {
+ // ensure that the notes tag is set up in the right location
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('contents', 'compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'extbinrelease', 'bundle', 'changelog'), $notes, 'notes');
+ }
+ $this->_packageInfo['notes'] = $notes;
+ }
+
+ /**
+ * This is only used at install-time, after all serialization
+ * is over.
+ * @param string file name
+ * @param string installed path
+ */
+ function setInstalledAs($file, $path)
+ {
+ if ($path) {
+ return $this->_packageInfo['filelist'][$file]['installed_as'] = $path;
+ }
+ unset($this->_packageInfo['filelist'][$file]['installed_as']);
+ }
+
+ /**
+ * This is only used at install-time, after all serialization
+ * is over.
+ */
+ function installedFile($file, $atts)
+ {
+ if (isset($this->_packageInfo['filelist'][$file])) {
+ $this->_packageInfo['filelist'][$file] =
+ array_merge($this->_packageInfo['filelist'][$file], $atts['attribs']);
+ } else {
+ $this->_packageInfo['filelist'][$file] = $atts['attribs'];
+ }
+ }
+
+ /**
+ * Reset the listing of package contents
+ * @param string base installation dir for the whole package, if any
+ */
+ function clearContents($baseinstall = false)
+ {
+ $this->_filesValid = false;
+ $this->_isValid = 0;
+ if (!isset($this->_packageInfo['contents'])) {
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('compatible',
+ 'dependencies', 'providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease',
+ 'extbinrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'bundle', 'changelog'), array(), 'contents');
+ }
+ if ($this->getPackageType() != 'bundle') {
+ $this->_packageInfo['contents'] =
+ array('dir' => array('attribs' => array('name' => '/')));
+ if ($baseinstall) {
+ $this->_packageInfo['contents']['dir']['attribs']['baseinstalldir'] = $baseinstall;
+ }
+ } else {
+ $this->_packageInfo['contents'] = array('bundledpackage' => array());
+ }
+ }
+
+ /**
+ * @param string relative path of the bundled package.
+ */
+ function addBundledPackage($path)
+ {
+ if ($this->getPackageType() != 'bundle') {
+ return false;
+ }
+ $this->_filesValid = false;
+ $this->_isValid = 0;
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $path, array(
+ 'contents' => array('compatible', 'dependencies', 'providesextension',
+ 'usesrole', 'usestask', 'srcpackage', 'srcuri', 'phprelease',
+ 'extsrcrelease', 'extbinrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'bundle', 'changelog'),
+ 'bundledpackage' => array()));
+ }
+
+ /**
+ * @param string file name
+ * @param PEAR_Task_Common a read/write task
+ */
+ function addTaskToFile($filename, $task)
+ {
+ if (!method_exists($task, 'getXml')) {
+ return false;
+ }
+ if (!method_exists($task, 'getName')) {
+ return false;
+ }
+ if (!method_exists($task, 'validate')) {
+ return false;
+ }
+ if (!$task->validate()) {
+ return false;
+ }
+ if (!isset($this->_packageInfo['contents']['dir']['file'])) {
+ return false;
+ }
+ $this->getTasksNs(); // discover the tasks namespace if not done already
+ $files = $this->_packageInfo['contents']['dir']['file'];
+ if (!isset($files[0])) {
+ $files = array($files);
+ $ind = false;
+ } else {
+ $ind = true;
+ }
+ foreach ($files as $i => $file) {
+ if (isset($file['attribs'])) {
+ if ($file['attribs']['name'] == $filename) {
+ if ($ind) {
+ $t = isset($this->_packageInfo['contents']['dir']['file'][$i]
+ ['attribs'][$this->_tasksNs .
+ ':' . $task->getName()]) ?
+ $this->_packageInfo['contents']['dir']['file'][$i]
+ ['attribs'][$this->_tasksNs .
+ ':' . $task->getName()] : false;
+ if ($t && !isset($t[0])) {
+ $this->_packageInfo['contents']['dir']['file'][$i]
+ [$this->_tasksNs . ':' . $task->getName()] = array($t);
+ }
+ $this->_packageInfo['contents']['dir']['file'][$i][$this->_tasksNs .
+ ':' . $task->getName()][] = $task->getXml();
+ } else {
+ $t = isset($this->_packageInfo['contents']['dir']['file']
+ ['attribs'][$this->_tasksNs .
+ ':' . $task->getName()]) ? $this->_packageInfo['contents']['dir']['file']
+ ['attribs'][$this->_tasksNs .
+ ':' . $task->getName()] : false;
+ if ($t && !isset($t[0])) {
+ $this->_packageInfo['contents']['dir']['file']
+ [$this->_tasksNs . ':' . $task->getName()] = array($t);
+ }
+ $this->_packageInfo['contents']['dir']['file'][$this->_tasksNs .
+ ':' . $task->getName()][] = $task->getXml();
+ }
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @param string path to the file
+ * @param string filename
+ * @param array extra attributes
+ */
+ function addFile($dir, $file, $attrs)
+ {
+ if ($this->getPackageType() == 'bundle') {
+ return false;
+ }
+ $this->_filesValid = false;
+ $this->_isValid = 0;
+ $dir = preg_replace(array('!\\\\+!', '!/+!'), array('/', '/'), $dir);
+ if ($dir == '/' || $dir == '') {
+ $dir = '';
+ } else {
+ $dir .= '/';
+ }
+ $attrs['name'] = $dir . $file;
+ if (!isset($this->_packageInfo['contents'])) {
+ // ensure that the contents tag is set up
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo,
+ array('compatible', 'dependencies', 'providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease',
+ 'extbinrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'bundle', 'changelog'), array(), 'contents');
+ }
+ if (isset($this->_packageInfo['contents']['dir']['file'])) {
+ if (!isset($this->_packageInfo['contents']['dir']['file'][0])) {
+ $this->_packageInfo['contents']['dir']['file'] =
+ array($this->_packageInfo['contents']['dir']['file']);
+ }
+ $this->_packageInfo['contents']['dir']['file'][]['attribs'] = $attrs;
+ } else {
+ $this->_packageInfo['contents']['dir']['file']['attribs'] = $attrs;
+ }
+ }
+
+ /**
+ * @param string Dependent package name
+ * @param string Dependent package's channel name
+ * @param string minimum version of specified package that this release is guaranteed to be
+ * compatible with
+ * @param string maximum version of specified package that this release is guaranteed to be
+ * compatible with
+ * @param string versions of specified package that this release is not compatible with
+ */
+ function addCompatiblePackage($name, $channel, $min, $max, $exclude = false)
+ {
+ $this->_isValid = 0;
+ $set = array(
+ 'name' => $name,
+ 'channel' => $channel,
+ 'min' => $min,
+ 'max' => $max,
+ );
+ if ($exclude) {
+ $set['exclude'] = $exclude;
+ }
+ $this->_isValid = 0;
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $set, array(
+ 'compatible' => array('dependencies', 'providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog')
+ ));
+ }
+
+ /**
+ * Removes the tag entirely
+ */
+ function resetUsesrole()
+ {
+ if (isset($this->_packageInfo['usesrole'])) {
+ unset($this->_packageInfo['usesrole']);
+ }
+ }
+
+ /**
+ * @param string
+ * @param string package name or uri
+ * @param string channel name if non-uri
+ */
+ function addUsesrole($role, $packageOrUri, $channel = false) {
+ $set = array('role' => $role);
+ if ($channel) {
+ $set['package'] = $packageOrUri;
+ $set['channel'] = $channel;
+ } else {
+ $set['uri'] = $packageOrUri;
+ }
+ $this->_isValid = 0;
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $set, array(
+ 'usesrole' => array('usestask', 'srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog')
+ ));
+ }
+
+ /**
+ * Removes the tag entirely
+ */
+ function resetUsestask()
+ {
+ if (isset($this->_packageInfo['usestask'])) {
+ unset($this->_packageInfo['usestask']);
+ }
+ }
+
+
+ /**
+ * @param string
+ * @param string package name or uri
+ * @param string channel name if non-uri
+ */
+ function addUsestask($task, $packageOrUri, $channel = false) {
+ $set = array('task' => $task);
+ if ($channel) {
+ $set['package'] = $packageOrUri;
+ $set['channel'] = $channel;
+ } else {
+ $set['uri'] = $packageOrUri;
+ }
+ $this->_isValid = 0;
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $set, array(
+ 'usestask' => array('srcpackage', 'srcuri',
+ 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog')
+ ));
+ }
+
+ /**
+ * Remove all compatible tags
+ */
+ function clearCompatible()
+ {
+ unset($this->_packageInfo['compatible']);
+ }
+
+ /**
+ * Reset dependencies prior to adding new ones
+ */
+ function clearDeps()
+ {
+ if (!isset($this->_packageInfo['dependencies'])) {
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, array(),
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog')));
+ }
+ $this->_packageInfo['dependencies'] = array();
+ }
+
+ /**
+ * @param string minimum PHP version allowed
+ * @param string maximum PHP version allowed
+ * @param array $exclude incompatible PHP versions
+ */
+ function setPhpDep($min, $max = false, $exclude = false)
+ {
+ $this->_isValid = 0;
+ $dep =
+ array(
+ 'min' => $min,
+ );
+ if ($max) {
+ $dep['max'] = $max;
+ }
+ if ($exclude) {
+ if (count($exclude) == 1) {
+ $exclude = $exclude[0];
+ }
+ $dep['exclude'] = $exclude;
+ }
+ if (isset($this->_packageInfo['dependencies']['required']['php'])) {
+ $this->_stack->push(__FUNCTION__, 'warning', array('dep' =>
+ $this->_packageInfo['dependencies']['required']['php']),
+ 'warning: PHP dependency already exists, overwriting');
+ unset($this->_packageInfo['dependencies']['required']['php']);
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ 'required' => array('optional', 'group'),
+ 'php' => array('pearinstaller', 'package', 'subpackage', 'extension', 'os', 'arch')
+ ));
+ return true;
+ }
+
+ /**
+ * @param string minimum allowed PEAR installer version
+ * @param string maximum allowed PEAR installer version
+ * @param string recommended PEAR installer version
+ * @param array incompatible version of the PEAR installer
+ */
+ function setPearinstallerDep($min, $max = false, $recommended = false, $exclude = false)
+ {
+ $this->_isValid = 0;
+ $dep =
+ array(
+ 'min' => $min,
+ );
+ if ($max) {
+ $dep['max'] = $max;
+ }
+ if ($recommended) {
+ $dep['recommended'] = $recommended;
+ }
+ if ($exclude) {
+ if (count($exclude) == 1) {
+ $exclude = $exclude[0];
+ }
+ $dep['exclude'] = $exclude;
+ }
+ if (isset($this->_packageInfo['dependencies']['required']['pearinstaller'])) {
+ $this->_stack->push(__FUNCTION__, 'warning', array('dep' =>
+ $this->_packageInfo['dependencies']['required']['pearinstaller']),
+ 'warning: PEAR Installer dependency already exists, overwriting');
+ unset($this->_packageInfo['dependencies']['required']['pearinstaller']);
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ 'required' => array('optional', 'group'),
+ 'pearinstaller' => array('package', 'subpackage', 'extension', 'os', 'arch')
+ ));
+ }
+
+ /**
+ * Mark a package as conflicting with this package
+ * @param string package name
+ * @param string package channel
+ * @param string extension this package provides, if any
+ * @param string|false minimum version required
+ * @param string|false maximum version allowed
+ * @param array|false versions to exclude from installation
+ */
+ function addConflictingPackageDepWithChannel($name, $channel,
+ $providesextension = false, $min = false, $max = false, $exclude = false)
+ {
+ $this->_isValid = 0;
+ $dep = $this->_constructDep($name, $channel, false, $min, $max, false,
+ $exclude, $providesextension, false, true);
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ 'required' => array('optional', 'group'),
+ 'package' => array('subpackage', 'extension', 'os', 'arch')
+ ));
+ }
+
+ /**
+ * Mark a package as conflicting with this package
+ * @param string package name
+ * @param string package channel
+ * @param string extension this package provides, if any
+ */
+ function addConflictingPackageDepWithUri($name, $uri, $providesextension = false)
+ {
+ $this->_isValid = 0;
+ $dep =
+ array(
+ 'name' => $name,
+ 'uri' => $uri,
+ 'conflicts' => '',
+ );
+ if ($providesextension) {
+ $dep['providesextension'] = $providesextension;
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ 'required' => array('optional', 'group'),
+ 'package' => array('subpackage', 'extension', 'os', 'arch')
+ ));
+ }
+
+ function addDependencyGroup($name, $hint)
+ {
+ $this->_isValid = 0;
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo,
+ array('attribs' => array('name' => $name, 'hint' => $hint)),
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ 'group' => array(),
+ ));
+ }
+
+ /**
+ * @param string package name
+ * @param string|false channel name, false if this is a uri
+ * @param string|false uri name, false if this is a channel
+ * @param string|false minimum version required
+ * @param string|false maximum version allowed
+ * @param string|false recommended installation version
+ * @param array|false versions to exclude from installation
+ * @param string extension this package provides, if any
+ * @param bool if true, tells the installer to ignore the default optional dependency group
+ * when installing this package
+ * @param bool if true, tells the installer to negate this dependency (conflicts)
+ * @return array
+ * @access private
+ */
+ function _constructDep($name, $channel, $uri, $min, $max, $recommended, $exclude,
+ $providesextension = false, $nodefault = false,
+ $conflicts = false)
+ {
+ $dep =
+ array(
+ 'name' => $name,
+ );
+ if ($channel) {
+ $dep['channel'] = $channel;
+ } elseif ($uri) {
+ $dep['uri'] = $uri;
+ }
+ if ($min) {
+ $dep['min'] = $min;
+ }
+ if ($max) {
+ $dep['max'] = $max;
+ }
+ if ($recommended) {
+ $dep['recommended'] = $recommended;
+ }
+ if ($exclude) {
+ if (is_array($exclude) && count($exclude) == 1) {
+ $exclude = $exclude[0];
+ }
+ $dep['exclude'] = $exclude;
+ }
+ if ($conflicts) {
+ $dep['conflicts'] = '';
+ }
+ if ($nodefault) {
+ $dep['nodefault'] = '';
+ }
+ if ($providesextension) {
+ $dep['providesextension'] = $providesextension;
+ }
+ return $dep;
+ }
+
+ /**
+ * @param package|subpackage
+ * @param string group name
+ * @param string package name
+ * @param string package channel
+ * @param string minimum version
+ * @param string maximum version
+ * @param string recommended version
+ * @param array|false optional excluded versions
+ * @param string extension this package provides, if any
+ * @param bool if true, tells the installer to ignore the default optional dependency group
+ * when installing this package
+ * @return bool false if the dependency group has not been initialized with
+ * {@link addDependencyGroup()}, or a subpackage is added with
+ * a providesextension
+ */
+ function addGroupPackageDepWithChannel($type, $groupname, $name, $channel, $min = false,
+ $max = false, $recommended = false, $exclude = false,
+ $providesextension = false, $nodefault = false)
+ {
+ if ($type == 'subpackage' && $providesextension) {
+ return false; // subpackages must be php packages
+ }
+ $dep = $this->_constructDep($name, $channel, false, $min, $max, $recommended, $exclude,
+ $providesextension, $nodefault);
+ return $this->_addGroupDependency($type, $dep, $groupname);
+ }
+
+ /**
+ * @param package|subpackage
+ * @param string group name
+ * @param string package name
+ * @param string package uri
+ * @param string extension this package provides, if any
+ * @param bool if true, tells the installer to ignore the default optional dependency group
+ * when installing this package
+ * @return bool false if the dependency group has not been initialized with
+ * {@link addDependencyGroup()}
+ */
+ function addGroupPackageDepWithURI($type, $groupname, $name, $uri, $providesextension = false,
+ $nodefault = false)
+ {
+ if ($type == 'subpackage' && $providesextension) {
+ return false; // subpackages must be php packages
+ }
+ $dep = $this->_constructDep($name, false, $uri, false, false, false, false,
+ $providesextension, $nodefault);
+ return $this->_addGroupDependency($type, $dep, $groupname);
+ }
+
+ /**
+ * @param string group name (must be pre-existing)
+ * @param string extension name
+ * @param string minimum version allowed
+ * @param string maximum version allowed
+ * @param string recommended version
+ * @param array incompatible versions
+ */
+ function addGroupExtensionDep($groupname, $name, $min = false, $max = false,
+ $recommended = false, $exclude = false)
+ {
+ $this->_isValid = 0;
+ $dep = $this->_constructDep($name, false, false, $min, $max, $recommended, $exclude);
+ return $this->_addGroupDependency('extension', $dep, $groupname);
+ }
+
+ /**
+ * @param package|subpackage|extension
+ * @param array dependency contents
+ * @param string name of the dependency group to add this to
+ * @return boolean
+ * @access private
+ */
+ function _addGroupDependency($type, $dep, $groupname)
+ {
+ $arr = array('subpackage', 'extension');
+ if ($type != 'package') {
+ array_shift($arr);
+ }
+ if ($type == 'extension') {
+ array_shift($arr);
+ }
+ if (!isset($this->_packageInfo['dependencies']['group'])) {
+ return false;
+ } else {
+ if (!isset($this->_packageInfo['dependencies']['group'][0])) {
+ if ($this->_packageInfo['dependencies']['group']['attribs']['name'] == $groupname) {
+ $this->_packageInfo['dependencies']['group'] = $this->_mergeTag(
+ $this->_packageInfo['dependencies']['group'], $dep,
+ array(
+ $type => $arr
+ ));
+ $this->_isValid = 0;
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ foreach ($this->_packageInfo['dependencies']['group'] as $i => $group) {
+ if ($group['attribs']['name'] == $groupname) {
+ $this->_packageInfo['dependencies']['group'][$i] = $this->_mergeTag(
+ $this->_packageInfo['dependencies']['group'][$i], $dep,
+ array(
+ $type => $arr
+ ));
+ $this->_isValid = 0;
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+ }
+
+ /**
+ * @param optional|required
+ * @param string package name
+ * @param string package channel
+ * @param string minimum version
+ * @param string maximum version
+ * @param string recommended version
+ * @param string extension this package provides, if any
+ * @param bool if true, tells the installer to ignore the default optional dependency group
+ * when installing this package
+ * @param array|false optional excluded versions
+ */
+ function addPackageDepWithChannel($type, $name, $channel, $min = false, $max = false,
+ $recommended = false, $exclude = false,
+ $providesextension = false, $nodefault = false)
+ {
+ if (!in_array($type, array('optional', 'required'), true)) {
+ $type = 'required';
+ }
+ $this->_isValid = 0;
+ $arr = array('optional', 'group');
+ if ($type != 'required') {
+ array_shift($arr);
+ }
+ $dep = $this->_constructDep($name, $channel, false, $min, $max, $recommended, $exclude,
+ $providesextension, $nodefault);
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ $type => $arr,
+ 'package' => array('subpackage', 'extension', 'os', 'arch')
+ ));
+ }
+
+ /**
+ * @param optional|required
+ * @param string name of the package
+ * @param string uri of the package
+ * @param string extension this package provides, if any
+ * @param bool if true, tells the installer to ignore the default optional dependency group
+ * when installing this package
+ */
+ function addPackageDepWithUri($type, $name, $uri, $providesextension = false,
+ $nodefault = false)
+ {
+ $this->_isValid = 0;
+ $arr = array('optional', 'group');
+ if ($type != 'required') {
+ array_shift($arr);
+ }
+ $dep = $this->_constructDep($name, false, $uri, false, false, false, false,
+ $providesextension, $nodefault);
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ $type => $arr,
+ 'package' => array('subpackage', 'extension', 'os', 'arch')
+ ));
+ }
+
+ /**
+ * @param optional|required optional, required
+ * @param string package name
+ * @param string package channel
+ * @param string minimum version
+ * @param string maximum version
+ * @param string recommended version
+ * @param array incompatible versions
+ * @param bool if true, tells the installer to ignore the default optional dependency group
+ * when installing this package
+ */
+ function addSubpackageDepWithChannel($type, $name, $channel, $min = false, $max = false,
+ $recommended = false, $exclude = false,
+ $nodefault = false)
+ {
+ $this->_isValid = 0;
+ $arr = array('optional', 'group');
+ if ($type != 'required') {
+ array_shift($arr);
+ }
+ $dep = $this->_constructDep($name, $channel, false, $min, $max, $recommended, $exclude,
+ $nodefault);
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ $type => $arr,
+ 'subpackage' => array('extension', 'os', 'arch')
+ ));
+ }
+
+ /**
+ * @param optional|required optional, required
+ * @param string package name
+ * @param string package uri for download
+ * @param bool if true, tells the installer to ignore the default optional dependency group
+ * when installing this package
+ */
+ function addSubpackageDepWithUri($type, $name, $uri, $nodefault = false)
+ {
+ $this->_isValid = 0;
+ $arr = array('optional', 'group');
+ if ($type != 'required') {
+ array_shift($arr);
+ }
+ $dep = $this->_constructDep($name, false, $uri, false, false, false, false, $nodefault);
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ $type => $arr,
+ 'subpackage' => array('extension', 'os', 'arch')
+ ));
+ }
+
+ /**
+ * @param optional|required optional, required
+ * @param string extension name
+ * @param string minimum version
+ * @param string maximum version
+ * @param string recommended version
+ * @param array incompatible versions
+ */
+ function addExtensionDep($type, $name, $min = false, $max = false, $recommended = false,
+ $exclude = false)
+ {
+ $this->_isValid = 0;
+ $arr = array('optional', 'group');
+ if ($type != 'required') {
+ array_shift($arr);
+ }
+ $dep = $this->_constructDep($name, false, false, $min, $max, $recommended, $exclude);
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ $type => $arr,
+ 'extension' => array('os', 'arch')
+ ));
+ }
+
+ /**
+ * @param string Operating system name
+ * @param boolean true if this package cannot be installed on this OS
+ */
+ function addOsDep($name, $conflicts = false)
+ {
+ $this->_isValid = 0;
+ $dep = array('name' => $name);
+ if ($conflicts) {
+ $dep['conflicts'] = '';
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ 'required' => array('optional', 'group'),
+ 'os' => array('arch')
+ ));
+ }
+
+ /**
+ * @param string Architecture matching pattern
+ * @param boolean true if this package cannot be installed on this architecture
+ */
+ function addArchDep($pattern, $conflicts = false)
+ {
+ $this->_isValid = 0;
+ $dep = array('pattern' => $pattern);
+ if ($conflicts) {
+ $dep['conflicts'] = '';
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, $dep,
+ array(
+ 'dependencies' => array('providesextension', 'usesrole', 'usestask',
+ 'srcpackage', 'srcuri', 'phprelease', 'extsrcrelease', 'extbinrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle', 'changelog'),
+ 'required' => array('optional', 'group'),
+ 'arch' => array()
+ ));
+ }
+
+ /**
+ * Set the kind of package, and erase all release tags
+ *
+ * - a php package is a PEAR-style package
+ * - an extbin package is a PECL-style extension binary
+ * - an extsrc package is a PECL-style source for a binary
+ * - an zendextbin package is a PECL-style zend extension binary
+ * - an zendextsrc package is a PECL-style source for a zend extension binary
+ * - a bundle package is a collection of other pre-packaged packages
+ * @param php|extbin|extsrc|zendextsrc|zendextbin|bundle
+ * @return bool success
+ */
+ function setPackageType($type)
+ {
+ $this->_isValid = 0;
+ if (!in_array($type, array('php', 'extbin', 'extsrc', 'zendextsrc',
+ 'zendextbin', 'bundle'))) {
+ return false;
+ }
+
+ if (in_array($type, array('zendextsrc', 'zendextbin'))) {
+ $this->_setPackageVersion2_1();
+ }
+
+ if ($type != 'bundle') {
+ $type .= 'release';
+ }
+
+ foreach (array('phprelease', 'extbinrelease', 'extsrcrelease',
+ 'zendextsrcrelease', 'zendextbinrelease', 'bundle') as $test) {
+ unset($this->_packageInfo[$test]);
+ }
+
+ if (!isset($this->_packageInfo[$type])) {
+ // ensure that the release tag is set up
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo, array('changelog'),
+ array(), $type);
+ }
+
+ $this->_packageInfo[$type] = array();
+ return true;
+ }
+
+ /**
+ * @return bool true if package type is set up
+ */
+ function addRelease()
+ {
+ if ($type = $this->getPackageType()) {
+ if ($type != 'bundle') {
+ $type .= 'release';
+ }
+ $this->_packageInfo = $this->_mergeTag($this->_packageInfo, array(),
+ array($type => array('changelog')));
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Get the current release tag in order to add to it
+ * @param bool returns only releases that have installcondition if true
+ * @return array|null
+ */
+ function &_getCurrentRelease($strict = true)
+ {
+ if ($p = $this->getPackageType()) {
+ if ($strict) {
+ if ($p == 'extsrc' || $p == 'zendextsrc') {
+ $a = null;
+ return $a;
+ }
+ }
+ if ($p != 'bundle') {
+ $p .= 'release';
+ }
+ if (isset($this->_packageInfo[$p][0])) {
+ return $this->_packageInfo[$p][count($this->_packageInfo[$p]) - 1];
+ } else {
+ return $this->_packageInfo[$p];
+ }
+ } else {
+ $a = null;
+ return $a;
+ }
+ }
+
+ /**
+ * Add a file to the current release that should be installed under a different name
+ * @param string path to file
+ * @param string name the file should be installed as
+ */
+ function addInstallAs($path, $as)
+ {
+ $r = &$this->_getCurrentRelease();
+ if ($r === null) {
+ return false;
+ }
+ $this->_isValid = 0;
+ $r = $this->_mergeTag($r, array('attribs' => array('name' => $path, 'as' => $as)),
+ array(
+ 'filelist' => array(),
+ 'install' => array('ignore')
+ ));
+ }
+
+ /**
+ * Add a file to the current release that should be ignored
+ * @param string path to file
+ * @return bool success of operation
+ */
+ function addIgnore($path)
+ {
+ $r = &$this->_getCurrentRelease();
+ if ($r === null) {
+ return false;
+ }
+ $this->_isValid = 0;
+ $r = $this->_mergeTag($r, array('attribs' => array('name' => $path)),
+ array(
+ 'filelist' => array(),
+ 'ignore' => array()
+ ));
+ }
+
+ /**
+ * Add an extension binary package for this extension source code release
+ *
+ * Note that the package must be from the same channel as the extension source package
+ * @param string
+ */
+ function addBinarypackage($package)
+ {
+ if ($this->getPackageType() != 'extsrc' && $this->getPackageType() != 'zendextsrc') {
+ return false;
+ }
+ $r = &$this->_getCurrentRelease(false);
+ if ($r === null) {
+ return false;
+ }
+ $this->_isValid = 0;
+ $r = $this->_mergeTag($r, $package,
+ array(
+ 'binarypackage' => array('filelist'),
+ ));
+ }
+
+ /**
+ * Add a configureoption to an extension source package
+ * @param string
+ * @param string
+ * @param string
+ */
+ function addConfigureOption($name, $prompt, $default = null)
+ {
+ if ($this->getPackageType() != 'extsrc' && $this->getPackageType() != 'zendextsrc') {
+ return false;
+ }
+
+ $r = &$this->_getCurrentRelease(false);
+ if ($r === null) {
+ return false;
+ }
+
+ $opt = array('attribs' => array('name' => $name, 'prompt' => $prompt));
+ if ($default !== null) {
+ $opt['attribs']['default'] = $default;
+ }
+
+ $this->_isValid = 0;
+ $r = $this->_mergeTag($r, $opt,
+ array(
+ 'configureoption' => array('binarypackage', 'filelist'),
+ ));
+ }
+
+ /**
+ * Set an installation condition based on php version for the current release set
+ * @param string minimum version
+ * @param string maximum version
+ * @param false|array incompatible versions of PHP
+ */
+ function setPhpInstallCondition($min, $max, $exclude = false)
+ {
+ $r = &$this->_getCurrentRelease();
+ if ($r === null) {
+ return false;
+ }
+ $this->_isValid = 0;
+ if (isset($r['installconditions']['php'])) {
+ unset($r['installconditions']['php']);
+ }
+ $dep = array('min' => $min, 'max' => $max);
+ if ($exclude) {
+ if (is_array($exclude) && count($exclude) == 1) {
+ $exclude = $exclude[0];
+ }
+ $dep['exclude'] = $exclude;
+ }
+ if ($this->getPackageType() == 'extsrc' || $this->getPackageType() == 'zendextsrc') {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('configureoption', 'binarypackage',
+ 'filelist'),
+ 'php' => array('extension', 'os', 'arch')
+ ));
+ } else {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('filelist'),
+ 'php' => array('extension', 'os', 'arch')
+ ));
+ }
+ }
+
+ /**
+ * @param optional|required optional, required
+ * @param string extension name
+ * @param string minimum version
+ * @param string maximum version
+ * @param string recommended version
+ * @param array incompatible versions
+ */
+ function addExtensionInstallCondition($name, $min = false, $max = false, $recommended = false,
+ $exclude = false)
+ {
+ $r = &$this->_getCurrentRelease();
+ if ($r === null) {
+ return false;
+ }
+ $this->_isValid = 0;
+ $dep = $this->_constructDep($name, false, false, $min, $max, $recommended, $exclude);
+ if ($this->getPackageType() == 'extsrc' || $this->getPackageType() == 'zendextsrc') {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('configureoption', 'binarypackage',
+ 'filelist'),
+ 'extension' => array('os', 'arch')
+ ));
+ } else {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('filelist'),
+ 'extension' => array('os', 'arch')
+ ));
+ }
+ }
+
+ /**
+ * Set an installation condition based on operating system for the current release set
+ * @param string OS name
+ * @param bool whether this OS is incompatible with the current release
+ */
+ function setOsInstallCondition($name, $conflicts = false)
+ {
+ $r = &$this->_getCurrentRelease();
+ if ($r === null) {
+ return false;
+ }
+ $this->_isValid = 0;
+ if (isset($r['installconditions']['os'])) {
+ unset($r['installconditions']['os']);
+ }
+ $dep = array('name' => $name);
+ if ($conflicts) {
+ $dep['conflicts'] = '';
+ }
+ if ($this->getPackageType() == 'extsrc' || $this->getPackageType() == 'zendextsrc') {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('configureoption', 'binarypackage',
+ 'filelist'),
+ 'os' => array('arch')
+ ));
+ } else {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('filelist'),
+ 'os' => array('arch')
+ ));
+ }
+ }
+
+ /**
+ * Set an installation condition based on architecture for the current release set
+ * @param string architecture pattern
+ * @param bool whether this arch is incompatible with the current release
+ */
+ function setArchInstallCondition($pattern, $conflicts = false)
+ {
+ $r = &$this->_getCurrentRelease();
+ if ($r === null) {
+ return false;
+ }
+ $this->_isValid = 0;
+ if (isset($r['installconditions']['arch'])) {
+ unset($r['installconditions']['arch']);
+ }
+ $dep = array('pattern' => $pattern);
+ if ($conflicts) {
+ $dep['conflicts'] = '';
+ }
+ if ($this->getPackageType() == 'extsrc' || $this->getPackageType() == 'zendextsrc') {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('configureoption', 'binarypackage',
+ 'filelist'),
+ 'arch' => array()
+ ));
+ } else {
+ $r = $this->_mergeTag($r, $dep,
+ array(
+ 'installconditions' => array('filelist'),
+ 'arch' => array()
+ ));
+ }
+ }
+
+ /**
+ * For extension binary releases, this is used to specify either the
+ * static URI to a source package, or the package name and channel of the extsrc/zendextsrc
+ * package it is based on.
+ * @param string Package name, or full URI to source package (extsrc/zendextsrc type)
+ */
+ function setSourcePackage($packageOrUri)
+ {
+ $this->_isValid = 0;
+ if (isset($this->_packageInfo['channel'])) {
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo, array('phprelease',
+ 'extsrcrelease', 'extbinrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'bundle', 'changelog'),
+ $packageOrUri, 'srcpackage');
+ } else {
+ $this->_packageInfo = $this->_insertBefore($this->_packageInfo, array('phprelease',
+ 'extsrcrelease', 'extbinrelease', 'zendextsrcrelease', 'zendextbinrelease',
+ 'bundle', 'changelog'), $packageOrUri, 'srcuri');
+ }
+ }
+
+ /**
+ * Generate a valid change log entry from the current package.xml
+ * @param string|false
+ */
+ function generateChangeLogEntry($notes = false)
+ {
+ return array(
+ 'version' =>
+ array(
+ 'release' => $this->getVersion('release'),
+ 'api' => $this->getVersion('api'),
+ ),
+ 'stability' =>
+ $this->getStability(),
+ 'date' => $this->getDate(),
+ 'license' => $this->getLicense(true),
+ 'notes' => $notes ? $notes : $this->getNotes()
+ );
+ }
+
+ /**
+ * @param string release version to set change log notes for
+ * @param array output of {@link generateChangeLogEntry()}
+ */
+ function setChangelogEntry($releaseversion, $contents)
+ {
+ if (!isset($this->_packageInfo['changelog'])) {
+ $this->_packageInfo['changelog']['release'] = $contents;
+ return;
+ }
+ if (!isset($this->_packageInfo['changelog']['release'][0])) {
+ if ($this->_packageInfo['changelog']['release']['version']['release'] == $releaseversion) {
+ $this->_packageInfo['changelog']['release'] = array(
+ $this->_packageInfo['changelog']['release']);
+ } else {
+ $this->_packageInfo['changelog']['release'] = array(
+ $this->_packageInfo['changelog']['release']);
+ return $this->_packageInfo['changelog']['release'][] = $contents;
+ }
+ }
+ foreach($this->_packageInfo['changelog']['release'] as $index => $changelog) {
+ if (isset($changelog['version']) &&
+ strnatcasecmp($changelog['version']['release'], $releaseversion) == 0) {
+ $curlog = $index;
+ }
+ }
+ if (isset($curlog)) {
+ $this->_packageInfo['changelog']['release'][$curlog] = $contents;
+ } else {
+ $this->_packageInfo['changelog']['release'][] = $contents;
+ }
+ }
+
+ /**
+ * Remove the changelog entirely
+ */
+ function clearChangeLog()
+ {
+ unset($this->_packageInfo['changelog']);
+ }
+} PEAR-1.10.1/PEAR/PackageFile/v2/Validator.php 0000644 0001750 0000144 00000246172 12610427352 017557 0 ustar cweiske users
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @link http://pear.php.net/package/PEAR
+ * @since File available since Release 1.4.0a8
+ */
+/**
+ * Private validation class used by PEAR_PackageFile_v2 - do not use directly, its
+ * sole purpose is to split up the PEAR/PackageFile/v2.php file to make it smaller
+ * @category pear
+ * @package PEAR
+ * @author Greg Beaver
+ * @copyright 1997-2009 The Authors
+ * @license http://opensource.org/licenses/bsd-license.php New BSD License
+ * @version Release: 1.10.1
+ * @link http://pear.php.net/package/PEAR
+ * @since Class available since Release 1.4.0a8
+ * @access private
+ */
+class PEAR_PackageFile_v2_Validator
+{
+ /**
+ * @var array
+ */
+ var $_packageInfo;
+ /**
+ * @var PEAR_PackageFile_v2
+ */
+ var $_pf;
+ /**
+ * @var PEAR_ErrorStack
+ */
+ var $_stack;
+ /**
+ * @var int
+ */
+ var $_isValid = 0;
+ /**
+ * @var int
+ */
+ var $_filesValid = 0;
+ /**
+ * @var int
+ */
+ var $_curState = 0;
+ /**
+ * @param PEAR_PackageFile_v2
+ * @param int
+ */
+ function validate(&$pf, $state = PEAR_VALIDATE_NORMAL)
+ {
+ $this->_pf = &$pf;
+ $this->_curState = $state;
+ $this->_packageInfo = $this->_pf->getArray();
+ $this->_isValid = $this->_pf->_isValid;
+ $this->_filesValid = $this->_pf->_filesValid;
+ $this->_stack = &$pf->_stack;
+ $this->_stack->getErrors(true);
+ if (($this->_isValid & $state) == $state) {
+ return true;
+ }
+ if (!isset($this->_packageInfo) || !is_array($this->_packageInfo)) {
+ return false;
+ }
+ if (!isset($this->_packageInfo['attribs']['version']) ||
+ ($this->_packageInfo['attribs']['version'] != '2.0' &&
+ $this->_packageInfo['attribs']['version'] != '2.1')
+ ) {
+ $this->_noPackageVersion();
+ }
+ $structure =
+ array(
+ 'name',
+ 'channel|uri',
+ '*extends', // can't be multiple, but this works fine
+ 'summary',
+ 'description',
+ '+lead', // these all need content checks
+ '*developer',
+ '*contributor',
+ '*helper',
+ 'date',
+ '*time',
+ 'version',
+ 'stability',
+ 'license->?uri->?filesource',
+ 'notes',
+ 'contents', //special validation needed
+ '*compatible',
+ 'dependencies', //special validation needed
+ '*usesrole',
+ '*usestask', // reserve these for 1.4.0a1 to implement
+ // this will allow a package.xml to gracefully say it
+ // needs a certain package installed in order to implement a role or task
+ '*providesextension',
+ '*srcpackage|*srcuri',
+ '+phprelease|+extsrcrelease|+extbinrelease|' .
+ '+zendextsrcrelease|+zendextbinrelease|bundle', //special validation needed
+ '*changelog',
+ );
+ $test = $this->_packageInfo;
+ if (isset($test['dependencies']) &&
+ isset($test['dependencies']['required']) &&
+ isset($test['dependencies']['required']['pearinstaller']) &&
+ isset($test['dependencies']['required']['pearinstaller']['min']) &&
+ '1.10.1' != '@package' . '_version@' &&
+ version_compare('1.10.1',
+ $test['dependencies']['required']['pearinstaller']['min'], '<')
+ ) {
+ $this->_pearVersionTooLow($test['dependencies']['required']['pearinstaller']['min']);
+ return false;
+ }
+ // ignore post-installation array fields
+ if (array_key_exists('filelist', $test)) {
+ unset($test['filelist']);
+ }
+ if (array_key_exists('_lastmodified', $test)) {
+ unset($test['_lastmodified']);
+ }
+ if (array_key_exists('#binarypackage', $test)) {
+ unset($test['#binarypackage']);
+ }
+ if (array_key_exists('old', $test)) {
+ unset($test['old']);
+ }
+ if (array_key_exists('_lastversion', $test)) {
+ unset($test['_lastversion']);
+ }
+ if (!$this->_stupidSchemaValidate($structure, $test, '')) {
+ return false;
+ }
+ if (empty($this->_packageInfo['name'])) {
+ $this->_tagCannotBeEmpty('name');
+ }
+ $test = isset($this->_packageInfo['uri']) ? 'uri' :'channel';
+ if (empty($this->_packageInfo[$test])) {
+ $this->_tagCannotBeEmpty($test);
+ }
+ if (is_array($this->_packageInfo['license']) &&
+ (!isset($this->_packageInfo['license']['_content']) ||
+ empty($this->_packageInfo['license']['_content']))) {
+ $this->_tagCannotBeEmpty('license');
+ } elseif (empty($this->_packageInfo['license'])) {
+ $this->_tagCannotBeEmpty('license');
+ }
+ if (empty($this->_packageInfo['summary'])) {
+ $this->_tagCannotBeEmpty('summary');
+ }
+ if (empty($this->_packageInfo['description'])) {
+ $this->_tagCannotBeEmpty('description');
+ }
+ if (empty($this->_packageInfo['date'])) {
+ $this->_tagCannotBeEmpty('date');
+ }
+ if (empty($this->_packageInfo['notes'])) {
+ $this->_tagCannotBeEmpty('notes');
+ }
+ if (isset($this->_packageInfo['time']) && empty($this->_packageInfo['time'])) {
+ $this->_tagCannotBeEmpty('time');
+ }
+ if (isset($this->_packageInfo['dependencies'])) {
+ $this->_validateDependencies();
+ }
+ if (isset($this->_packageInfo['compatible'])) {
+ $this->_validateCompatible();
+ }
+ if (!isset($this->_packageInfo['bundle'])) {
+ if (empty($this->_packageInfo['contents'])) {
+ $this->_tagCannotBeEmpty('contents');
+ }
+ if (!isset($this->_packageInfo['contents']['dir'])) {
+ $this->_filelistMustContainDir('contents');
+ return false;
+ }
+ if (isset($this->_packageInfo['contents']['file'])) {
+ $this->_filelistCannotContainFile('contents');
+ return false;
+ }
+ }
+ $this->_validateMaintainers();
+ $this->_validateStabilityVersion();
+ $fail = false;
+ if (array_key_exists('usesrole', $this->_packageInfo)) {
+ $roles = $this->_packageInfo['usesrole'];
+ if (!is_array($roles) || !isset($roles[0])) {
+ $roles = array($roles);
+ }
+ foreach ($roles as $role) {
+ if (!isset($role['role'])) {
+ $this->_usesroletaskMustHaveRoleTask('usesrole', 'role');
+ $fail = true;
+ } else {
+ if (!isset($role['channel'])) {
+ if (!isset($role['uri'])) {
+ $this->_usesroletaskMustHaveChannelOrUri($role['role'], 'usesrole');
+ $fail = true;
+ }
+ } elseif (!isset($role['package'])) {
+ $this->_usesroletaskMustHavePackage($role['role'], 'usesrole');
+ $fail = true;
+ }
+ }
+ }
+ }
+ if (array_key_exists('usestask', $this->_packageInfo)) {
+ $roles = $this->_packageInfo['usestask'];
+ if (!is_array($roles) || !isset($roles[0])) {
+ $roles = array($roles);
+ }
+ foreach ($roles as $role) {
+ if (!isset($role['task'])) {
+ $this->_usesroletaskMustHaveRoleTask('usestask', 'task');
+ $fail = true;
+ } else {
+ if (!isset($role['channel'])) {
+ if (!isset($role['uri'])) {
+ $this->_usesroletaskMustHaveChannelOrUri($role['task'], 'usestask');
+ $fail = true;
+ }
+ } elseif (!isset($role['package'])) {
+ $this->_usesroletaskMustHavePackage($role['task'], 'usestask');
+ $fail = true;
+ }
+ }
+ }
+ }
+
+ if ($fail) {
+ return false;
+ }
+
+ $list = $this->_packageInfo['contents'];
+ if (isset($list['dir']) && is_array($list['dir']) && isset($list['dir'][0])) {
+ $this->_multipleToplevelDirNotAllowed();
+ return $this->_isValid = 0;
+ }
+
+ $this->_validateFilelist();
+ $this->_validateRelease();
+ if (!$this->_stack->hasErrors()) {
+ $chan = $this->_pf->_registry->getChannel($this->_pf->getChannel(), true);
+ if (PEAR::isError($chan)) {
+ $this->_unknownChannel($this->_pf->getChannel());
+ } else {
+ $valpack = $chan->getValidationPackage();
+ // for channel validator packages, always use the default PEAR validator.
+ // otherwise, they can't be installed or packaged
+ $validator = $chan->getValidationObject($this->_pf->getPackage());
+ if (!$validator) {
+ $this->_stack->push(__FUNCTION__, 'error',
+ array('channel' => $chan->getName(),
+ 'package' => $this->_pf->getPackage(),
+ 'name' => $valpack['_content'],
+ 'version' => $valpack['attribs']['version']),
+ 'package "%channel%/%package%" cannot be properly validated without ' .
+ 'validation package "%channel%/%name%-%version%"');
+ return $this->_isValid = 0;
+ }
+ $validator->setPackageFile($this->_pf);
+ $validator->validate($state);
+ $failures = $validator->getFailures();
+ foreach ($failures['errors'] as $error) {
+ $this->_stack->push(__FUNCTION__, 'error', $error,
+ 'Channel validator error: field "%field%" - %reason%');
+ }
+ foreach ($failures['warnings'] as $warning) {
+ $this->_stack->push(__FUNCTION__, 'warning', $warning,
+ 'Channel validator warning: field "%field%" - %reason%');
+ }
+ }
+ }
+
+ $this->_pf->_isValid = $this->_isValid = !$this->_stack->hasErrors('error');
+ if ($this->_isValid && $state == PEAR_VALIDATE_PACKAGING && !$this->_filesValid) {
+ if ($this->_pf->getPackageType() == 'bundle') {
+ if ($this->_analyzeBundledPackages()) {
+ $this->_filesValid = $this->_pf->_filesValid = true;
+ } else {
+ $this->_pf->_isValid = $this->_isValid = 0;
+ }
+ } else {
+ if (!$this->_analyzePhpFiles()) {
+ $this->_pf->_isValid = $this->_isValid = 0;
+ } else {
+ $this->_filesValid = $this->_pf->_filesValid = true;
+ }
+ }
+ }
+
+ if ($this->_isValid) {
+ return $this->_pf->_isValid = $this->_isValid = $state;
+ }
+
+ return $this->_pf->_isValid = $this->_isValid = 0;
+ }
+
+ function _stupidSchemaValidate($structure, $xml, $root)
+ {
+ if (!is_array($xml)) {
+ $xml = array();
+ }
+ $keys = array_keys($xml);
+ reset($keys);
+ $key = current($keys);
+ while ($key == 'attribs' || $key == '_contents') {
+ $key = next($keys);
+ }
+ $unfoundtags = $optionaltags = array();
+ $ret = true;
+ $mismatch = false;
+ foreach ($structure as $struc) {
+ if ($key) {
+ $tag = $xml[$key];
+ }
+ $test = $this->_processStructure($struc);
+ if (isset($test['choices'])) {
+ $loose = true;
+ foreach ($test['choices'] as $choice) {
+ if ($key == $choice['tag']) {
+ $key = next($keys);
+ while ($key == 'attribs' || $key == '_contents') {
+ $key = next($keys);
+ }
+ $unfoundtags = $optionaltags = array();
+ $mismatch = false;
+ if ($key && $key != $choice['tag'] && isset($choice['multiple'])) {
+ $unfoundtags[] = $choice['tag'];
+ $optionaltags[] = $choice['tag'];
+ if ($key) {
+ $mismatch = true;
+ }
+ }
+ $ret &= $this->_processAttribs($choice, $tag, $root);
+ continue 2;
+ } else {
+ $unfoundtags[] = $choice['tag'];
+ $mismatch = true;
+ }
+ if (!isset($choice['multiple']) || $choice['multiple'] != '*') {
+ $loose = false;
+ } else {
+ $optionaltags[] = $choice['tag'];
+ }
+ }
+ if (!$loose) {
+ $this->_invalidTagOrder($unfoundtags, $key, $root);
+ return false;
+ }
+ } else {
+ if ($key != $test['tag']) {
+ if (isset($test['multiple']) && $test['multiple'] != '*') {
+ $unfoundtags[] = $test['tag'];
+ $this->_invalidTagOrder($unfoundtags, $key, $root);
+ return false;
+ } else {
+ if ($key) {
+ $mismatch = true;
+ }
+ $unfoundtags[] = $test['tag'];
+ $optionaltags[] = $test['tag'];
+ }
+ if (!isset($test['multiple'])) {
+ $this->_invalidTagOrder($unfoundtags, $key, $root);
+ return false;
+ }
+ continue;
+ } else {
+ $unfoundtags = $optionaltags = array();
+ $mismatch = false;
+ }
+ $key = next($keys);
+ while ($key == 'attribs' || $key == '_contents') {
+ $key = next($keys);
+ }
+ if ($key && $key != $test['tag'] && isset($test['multiple'])) {
+ $unfoundtags[] = $test['tag'];
+ $optionaltags[] = $test['tag'];
+ $mismatch = true;
+ }
+ $ret &= $this->_processAttribs($test, $tag, $root);
+ continue;
+ }
+ }
+ if (!$mismatch && count($optionaltags)) {
+ // don't error out on any optional tags
+ $unfoundtags = array_diff($unfoundtags, $optionaltags);
+ }
+ if (count($unfoundtags)) {
+ $this->_invalidTagOrder($unfoundtags, $key, $root);
+ } elseif ($key) {
+ // unknown tags
+ $this->_invalidTagOrder('*no tags allowed here*', $key, $root);
+ while ($key = next($keys)) {
+ $this->_invalidTagOrder('*no tags allowed here*', $key, $root);
+ }
+ }
+ return $ret;
+ }
+
+ function _processAttribs($choice, $tag, $context)
+ {
+ if (isset($choice['attribs'])) {
+ if (!is_array($tag)) {
+ $tag = array($tag);
+ }
+ $tags = $tag;
+ if (!isset($tags[0])) {
+ $tags = array($tags);
+ }
+ $ret = true;
+ foreach ($tags as $i => $tag) {
+ if (!is_array($tag) || !isset($tag['attribs'])) {
+ foreach ($choice['attribs'] as $attrib) {
+ if ($attrib{0} != '?') {
+ $ret &= $this->_tagHasNoAttribs($choice['tag'],
+ $context);
+ continue 2;
+ }
+ }
+ }
+ foreach ($choice['attribs'] as $attrib) {
+ if ($attrib{0} != '?') {
+ if (!isset($tag['attribs'][$attrib])) {
+ $ret &= $this->_tagMissingAttribute($choice['tag'],
+ $attrib, $context);
+ }
+ }
+ }
+ }
+ return $ret;
+ }
+ return true;
+ }
+
+ function _processStructure($key)
+ {
+ $ret = array();
+ if (count($pieces = explode('|', $key)) > 1) {
+ $ret['choices'] = array();
+ foreach ($pieces as $piece) {
+ $ret['choices'][] = $this->_processStructure($piece);
+ }
+ return $ret;
+ }
+ $multi = $key{0};
+ if ($multi == '+' || $multi == '*') {
+ $ret['multiple'] = $key{0};
+ $key = substr($key, 1);
+ }
+ if (count($attrs = explode('->', $key)) > 1) {
+ $ret['tag'] = array_shift($attrs);
+ $ret['attribs'] = $attrs;
+ } else {
+ $ret['tag'] = $key;
+ }
+ return $ret;
+ }
+
+ function _validateStabilityVersion()
+ {
+ $structure = array('release', 'api');
+ $a = $this->_stupidSchemaValidate($structure, $this->_packageInfo['version'], '');
+ $a &= $this->_stupidSchemaValidate($structure, $this->_packageInfo['stability'], '');
+ if ($a) {
+ if (!preg_match('/^\d+(?:\.\d+)*(?:[a-zA-Z]+\d*)?\\z/',
+ $this->_packageInfo['version']['release'])) {
+ $this->_invalidVersion('release', $this->_packageInfo['version']['release']);
+ }
+ if (!preg_match('/^\d+(?:\.\d+)*(?:[a-zA-Z]+\d*)?\\z/',
+ $this->_packageInfo['version']['api'])) {
+ $this->_invalidVersion('api', $this->_packageInfo['version']['api']);
+ }
+ if (!in_array($this->_packageInfo['stability']['release'],
+ array('snapshot', 'devel', 'alpha', 'beta', 'stable'))) {
+ $this->_invalidState('release', $this->_packageInfo['stability']['release']);
+ }
+ if (!in_array($this->_packageInfo['stability']['api'],
+ array('devel', 'alpha', 'beta', 'stable'))) {
+ $this->_invalidState('api', $this->_packageInfo['stability']['api']);
+ }
+ }
+ }
+
+ function _validateMaintainers()
+ {
+ $structure =
+ array(
+ 'name',
+ 'user',
+ 'email',
+ 'active',
+ );
+ foreach (array('lead', 'developer', 'contributor', 'helper') as $type) {
+ if (!isset($this->_packageInfo[$type])) {
+ continue;
+ }
+ if (isset($this->_packageInfo[$type][0])) {
+ foreach ($this->_packageInfo[$type] as $lead) {
+ $this->_stupidSchemaValidate($structure, $lead, '<' . $type . '>');
+ }
+ } else {
+ $this->_stupidSchemaValidate($structure, $this->_packageInfo[$type],
+ '<' . $type . '>');
+ }
+ }
+ }
+
+ function _validatePhpDep($dep, $installcondition = false)
+ {
+ $structure = array(
+ 'min',
+ '*max',
+ '*exclude',
+ );
+ $type = $installcondition ? '' : '';
+ $this->_stupidSchemaValidate($structure, $dep, $type);
+ if (isset($dep['min'])) {
+ if (!preg_match('/^\d+(?:\.\d+)*(?:[a-zA-Z]+\d*)?(?:-[a-zA-Z0-9]+)?\\z/',
+ $dep['min'])) {
+ $this->_invalidVersion($type . '', $dep['min']);
+ }
+ }
+ if (isset($dep['max'])) {
+ if (!preg_match('/^\d+(?:\.\d+)*(?:[a-zA-Z]+\d*)?(?:-[a-zA-Z0-9]+)?\\z/',
+ $dep['max'])) {
+ $this->_invalidVersion($type . '', $dep['max']);
+ }
+ }
+ if (isset($dep['exclude'])) {
+ if (!is_array($dep['exclude'])) {
+ $dep['exclude'] = array($dep['exclude']);
+ }
+ foreach ($dep['exclude'] as $exclude) {
+ if (!preg_match(
+ '/^\d+(?:\.\d+)*(?:[a-zA-Z]+\d*)?(?:-[a-zA-Z0-9]+)?\\z/',
+ $exclude)) {
+ $this->_invalidVersion($type . '', $exclude);
+ }
+ }
+ }
+ }
+
+ function _validatePearinstallerDep($dep)
+ {
+ $structure = array(
+ 'min',
+ '*max',
+ '*recommended',
+ '*exclude',
+ );
+ $this->_stupidSchemaValidate($structure, $dep, '');
+ if (isset($dep['min'])) {
+ if (!preg_match('/^\d+(?:\.\d+)*(?:[a-zA-Z]+\d*)?\\z/',
+ $dep['min'])) {
+ $this->_invalidVersion('