mirror/Mineplex
mirror/Mineplex
1
Fork 0
Code Releases Activity
76a7ae65df
Mineplex/.FILES USED TO GET TO WHERE WE ARE PRESENTLY/xampp/php/tests/parseFile/PackageUpdate.php

1094 lines
36 KiB
PHP
Raw Normal View History

PUUUUUSH
2023-05-17 21:44:01 +00:00
<?php
/**
* A package to make adding self updating functionality to other
* packages easy.
*
* PHP versions 4 and 5
*
* LICENSE: This source file is subject to version 3.01 of the PHP license
* that is available through the world-wide-web at the following URI:
* http://www.php.net/license/3_01.txt. If you did not receive a copy of
* the PHP License and are unable to obtain it through the web, please
* send a note to license@php.net so we can mail you a copy immediately.
*
* @category PEAR
* @package PEAR_PackageUpdate
* @author Scott Mattocks
* @copyright 2006 Scott Mattocks
* @license http://www.php.net/license/3_01.txt PHP License 3.01
* @version CVS: $Id: PackageUpdate.php,v 1.1 2008/02/02 15:09:40 farell Exp $
* @link http://pear.php.net/package/PEAR_PackageUpdate
* @since File available since Release 0.4.0a1
*/
require_once 'PEAR/ErrorStack.php';
require_once 'PEAR/Config.php';
// Constants for preferences.
define('PEAR_PACKAGEUPDATE_PREF_NOUPDATES', 0);
define('PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE', 1);
define('PEAR_PACKAGEUPDATE_PREF_TYPE', 2);
define('PEAR_PACKAGEUPDATE_PREF_STATE', 3);
// Constants for states.
define('PEAR_PACKAGEUPDATE_STATE_DEVEL', 'devel');
define('PEAR_PACKAGEUPDATE_STATE_ALPHA', 'alpha');
define('PEAR_PACKAGEUPDATE_STATE_BETA', 'beta');
define('PEAR_PACKAGEUPDATE_STATE_STABLE', 'stable');
// Constants for release types.
define('PEAR_PACKAGEUPDATE_TYPE_BUG', 'bug');
define('PEAR_PACKAGEUPDATE_TYPE_MINOR', 'minor');
define('PEAR_PACKAGEUPDATE_TYPE_MAJOR', 'major');
// Constants for errors.
define('PEAR_PACKAGEUPDATE_ERROR_NOPACKAGE', -1);
define('PEAR_PACKAGEUPDATE_ERROR_NOCHANNEL', -2);
define('PEAR_PACKAGEUPDATE_ERROR_NOINFO', -3);
define('PEAR_PACKAGEUPDATE_ERROR_NOTINSTALLED', -4);
define('PEAR_PACKAGEUPDATE_ERROR_PREFFILE_READACCESS', -5);
define('PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEACCESS', -6);
define('PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEERROR', -7);
define('PEAR_PACKAGEUPDATE_ERROR_PREFFILE_CORRUPTED', -8);
define('PEAR_PACKAGEUPDATE_ERROR_INVALIDTYPE', -9);
define('PEAR_PACKAGEUPDATE_ERROR_INVALIDSTATE', -10);
define('PEAR_PACKAGEUPDATE_ERROR_INVALIDPREF', -11);
define('PEAR_PACKAGEUPDATE_ERROR_NONEXISTENTDRIVER', -12);
// Error messages.
$GLOBALS['_PEAR_PACKAGEUPDATE_ERRORS'] =
array(
PEAR_PACKAGEUPDATE_ERROR_NOPACKAGE =>
'No package name provided',
PEAR_PACKAGEUPDATE_ERROR_NOCHANNEL =>
'No channel name provided',
PEAR_PACKAGEUPDATE_ERROR_NOINFO =>
'No update information is available for %packagename%.',
PEAR_PACKAGEUPDATE_ERROR_NOTINSTALLED =>
'%packagename% is not installed. It cannot be updated.',
PEAR_PACKAGEUPDATE_ERROR_PREFFILE_READACCESS =>
'Preferences cannot be read from %file%.',
PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEACCESS =>
'Preferences cannot be written to %file% because of access permission errors.',
PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEERROR =>
'An error occurred while trying to write the preferences to %file%.',
PEAR_PACKAGEUPDATE_ERROR_PREFFILE_CORRUPTED =>
'Preferences file is corrupted.',
PEAR_PACKAGEUPDATE_ERROR_INVALIDTYPE =>
'Invalid release type: %type%',
PEAR_PACKAGEUPDATE_ERROR_INVALIDSTATE =>
'Invalid release state: %state%',
PEAR_PACKAGEUPDATE_ERROR_INVALIDPREF =>
'Invalid preference: %preference%',
PEAR_PACKAGEUPDATE_ERROR_NONEXISTENTDRIVER =>
'Driver %drivername% could not be found.'
);
/**
* The package allows a developer to add a few lines of code to
* their existing packages and have the ability to update their
* package automatically. This auto-update ability allows users
* to stay up to date much more easily than requiring them to
* update manually.
*
* This package keeps track of user preferences such as "don't
* remind me again".
*
* This package is designed to be a backend to different front
* ends written for this package. For example, this package can
* be used to drive a PHP-GTK 2, CLI or web front end. The API
* for this package should be flexible enough to allow any type
* of front end to be used and also to allow the package to be
* used directly in another package without a front end driver.
*
* The interface for this package must allow for the following
* functionality:
* - check to see if a new version is available for a given
* package on a given channel
* - check minimum state
* - present information regarding the upgrade (version, size)
* - inform user about dependencies
* - allow user to confirm or cancel upgrade
* - download and install the package
* - track preferences on a per package basis
* - don't ask again
* - don't ask until next release
* - only ask for state XXXX or higher
* - bug/minor/major updates only
* - update channel automatically
* - force application to exit when upgrade complete
* - PHP-GTK/CLI apps must exit to allow classes to reload
* - web front end could send headers to reload certain page
*
* This class is simply a wrapper for PEAR classes that actually
* do the work.
*
* EXAMPLE:
* <code>
* <?php
* class Goo {
* function __construct()
* {
* // Check for updates...
* require_once 'PEAR/PackageUpdate.php';
* $ppu =& PEAR_PackageUpdate::factory('Gtk2', 'Goo', 'pear');
* if ($ppu !== false) {
* if ($ppu->checkUpdate()) {
* // Use a dialog window to ask permission to update.
* if ($ppu->presentUpdate()) {
* if ($ppu->update()) {
* // If the update succeeded, the application should
* // be restarted.
* $ppu->forceRestart();
* }
* }
* }
* }
* // ...
* }
* // ...
* }
* ?>
* </code>
*
* @category PEAR
* @package PEAR_PackageUpdate
* @author Scott Mattocks
* @copyright 2006 Scott Mattocks
* @license http://www.php.net/license/3_01.txt PHP License 3.01
* @version Release: 0.5.0
* @link http://pear.php.net/package/PEAR_PackageUpdate
* @since Class available since Release 0.4.0a1
*/
class PEAR_PackageUpdate
{
/**
* The user's update preferences.
*
* @access public
* @var array
* @since 0.4.0a1
*/
var $preferences = array();
/**
* The name of the package.
*
* @access public
* @var string
* @since 0.4.0a1
*/
var $packageName;
/**
* The channel the package is hosted on.
*
* @access public
* @var string
* @since 0.4.0a1
*/
var $channel;
/**
* The latest version available for the given package.
*
* @access public
* @var string
* @since 0.4.0a1
*/
var $latestVersion;
/**
* Information about the latest version of the package.
*
* @access public
* @var array
* @since 0.4.0a1
*/
var $info = array();
/**
* The current installed version of the package.
*
* @access public
* @var string
* @since 0.4.0a1
*/
var $instVersion;
/**
* A collection of errors that have occurred.
*
* @access public
* @var object
* @since 0.4.0a1
*/
var $errors;
/**
* PHP 4 style constructor. Calls the PHP 5 style constructor.
*
* @access public
* @param string $packageName The package to update.
* @param string $channel The channel the package resides on.
* @return void
* @since 0.4.0a1
*/
function PEAR_PackageUpdate($packageName, $channel)
{
PEAR_PackageUpdate::__construct($packageName, $channel);
}
/**
* PHP 5 style constructor. Loads the user preferences.
*
* @access public
* @param string $packageName The package to update.
* @param string $channel The channel the package resides on.
* @return void
* @since 0.4.0a1
*/
function __construct($packageName, $channel)
{
// Create a pear error stack.
$this->errors =& PEAR_ErrorStack::singleton(get_class($this));
$this->errors->setContextCallback(array(&$this, '_getBacktrace'));
// Set the package name and channel.
$this->packageName = $packageName;
$this->channel = $channel;
// Load the user's preferences.
$this->loadPreferences();
}
/**
* Callback that generates context information (location of error)
* for the package error stack.
*
* @access private
* @return mixed backtrace context array or false is unavailable
* @since 0.4.3
*/
function _getBacktrace()
{
if (function_exists('debug_backtrace')) {
$backtrace = debug_backtrace();
$backtrace = $backtrace[count($backtrace)-1];
} else {
$backtrace = false;
}
return $backtrace;
}
/**
* Creates an instance of the given update class.
*
* @access public
* @param string $driver The type of PPU to create.
* @param string $packageName The package to update.
* @param string $channel The channel the package resides on.
* @return object An instance of type PEAR_PackageUpdate_$driver
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_NONEXISTENTDRIVER
*/
function &factory($driver, $packageName, $channel)
{
$class = 'PEAR_PackageUpdate_' . $driver;
// Attempt to include a custom version of the named class, but don't treat
// a failure as fatal. The caller may have already included their own
// version of the named class.
if (!class_exists($class)) {
// Try to include the driver.
$file = 'PEAR/PackageUpdate/' . $driver . '.php';
if (!PEAR_PackageUpdate::isIncludable($file)) {
PEAR_ErrorStack::staticPush('PEAR_PackageUpdate',
PEAR_PACKAGEUPDATE_ERROR_NONEXISTENTDRIVER,
null,
array('drivername' => $driver),
$GLOBALS['_PEAR_PACKAGEUPDATE_ERRORS'][PEAR_PACKAGEUPDATE_ERROR_NONEXISTENTDRIVER]
);
// Must assign a variable to avoid notice about references.
$false = false;
return $false;
}
include_once $file;
}
// See if the class exists now.
if (!class_exists($class)) {
// Must assign a variable to avoid notice about references.
$false = false;
return $false;
}
// Try to instantiate the class.
$instance =& new $class($packageName, $channel);
return $instance;
}
/**
* Returns whether or not a path is in the include path.
*
* @static
* @access public
* @param string $path
* @return boolean true if the path is in the include path.
* @since 0.4.2
*/
function isIncludable($path)
{
// Break up the include path and check to see if the path is readable.
foreach (explode(PATH_SEPARATOR, get_include_path()) as $ip) {
if (file_exists($ip . DIRECTORY_SEPARATOR . $path) &&
is_readable($ip . DIRECTORY_SEPARATOR . $path)
) {
return true;
}
}
// If we got down here, the path is not readable from the include path.
return false;
}
/**
* Loads the user's preferences from a file.
*
* The preferences are stored in the user's home directory
* as the file .ppurc. The file contains a serialized array
* of preferences for each package that has been checked for
* updates so far.
*
* @access protected
* @return boolean true on success, false on error
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_PREFFILE_READACCESS,
* PEAR_PACKAGEUPDATE_ERROR_PREFFILE_CORRUPTED
*/
function loadPreferences()
{
// Get the preferences file.
$prefFile = $this->determinePrefFile();
// Make sure the prefFile exists.
if (!@file_exists($prefFile)) {
// Try to create it by saving the current preferences (probably
// just an empty array).
$this->savePreferences();
}
// Make sure the prefFile is readable.
if (!@is_readable($prefFile)) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_PREFFILE_READACCESS,
NULL, array('file' => $prefFile)
);
return false;
}
// Get the contents of the prefFile.
$contents = file_get_contents($prefFile);
// Unserialize the data.
$preferences = unserialize($contents);
// Make sure the contents were unserialized properly.
// Borrowed from PEAR_Config.
if (!$preferences && strlen($contents) > 7) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_PREFFILE_CORRUPTED);
return false;
}
$this->preferences = $preferences;
return true;
}
/**
* Returns the path to the preferences file.
*
* @access protected
* @return string
* @since 0.4.0a1
*/
function determinePrefFile()
{
// Determine the preferences file.
// Borrowed from PEAR_Config
$ds = DIRECTORY_SEPARATOR;
if (OS_WINDOWS) {
$prefFile = PEAR_CONFIG_SYSCONFDIR . $ds . 'ppurc.ini';
} else {
$prefFile = getenv('HOME') . $ds . '.ppurc';
}
return $prefFile;
}
/**
* Checks to see if an update is available.
*
* Respects the user preferences when determining if an
* update is avaiable. Returns true if an update is available
* and the user may want to update the package.
*
* @access public
* @return boolean true if an update is available.
* @since 0.4.0a1
*/
function checkUpdate()
{
// Check to see if an update is available.
if (empty($this->latestVersion) || empty ($this->info)) {
if (!$this->getPackageInfo()) {
return false;
}
}
// See if the installed version is older than the current version.
if (version_compare($this->latestVersion, $this->instVersion, '>')) {
// Check to see if the user's preferences allow an update.
if (!$this->preferencesAllowUpdate()) {
// User doesn't want to update to the latest version.
return false;
}
return true;
} else {
return false;
}
}
/**
* Returns the latest information about the given package.
*
* @access protected
* @return boolean true on success, false on error
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_NOPACKAGE,
* PEAR_PACKAGEUPDATE_ERROR_NOCHANNEL,
* PEAR_PACKAGEUPDATE_ERROR_NOINFO
*/
function getPackageInfo()
{
// Only check once.
if (isset($this->latestVersion) && isset($this->info)) {
return true;
}
// Make sure the channel and package are set.
if (empty($this->packageName)) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_NOPACKAGE);
return false;
}
if (empty($this->channel)) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_NOCHANNEL);
return false;
}
// Create a config object.
$config = new PEAR_Config();
// Get the config's registry object.
$reg = $config->getRegistry();
// Parse the package name.
$parsed = $reg->parsePackageName($this->channel . '/' . $this->packageName);
// Check for errors.
if (PEAR::isError($parsed)) {
$this->pushError($parsed);
return false;
}
// Get a PEAR_Remote instance.
$r = $config->getRemote();
// Get the package info.
$info = $r->call('package.info', $parsed['package']);
// Check to make sure the package was found.
if (PEAR::isError($info)) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_NOINFO, NULL,
array('packagename' => $this->packageName)
);
return false;
}
// Get the installed version of the package.
$this->instVersion = $reg->packageInfo($parsed['package'],
'version',
$parsed['channel']
);
// If the package is not installed, create a dummy version.
if (empty($this->instVersion)) {
$this->instVersion = '0.0.0';
}
// Pull out the latest information.
$this->latestVersion = reset(array_keys($info['releases']));
$this->info = reset($info['releases']);
return true;
}
/**
* Returns the preferences associated with the given package.
*
* The preferences returned are an array with the folling values:
* - don't ask again
* - don't ask until next version
* - only ask for state x
* - bug/minor/major updates only
*
* @access public
* @return array
* @since 0.4.0a1
*/
function getPackagePreferences()
{
if (isset($this->preferences[$this->channel][$this->packageName])) {
return $this->preferences[$this->channel][$this->packageName];
} else {
return array();
}
}
/**
* Saves the current prefernces to the RC file.
*
* @access public
* @return boolean true on success, false on error
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEACCESS,
* PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEERROR
*/
function savePreferences()
{
// Get the file to save the preferences to.
$prefFile = $this->determinePrefFile();
// Open the file for writing.
$fp = fopen($prefFile, 'w');
if ($fp === false) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEACCESS,
NULL, array('file' => $prefFile)
);
return false;
}
// Serialize the contents.
$serialCont = serialize($this->preferences);
// Write the contents to the file.
if (fwrite($fp, $serialCont) === false) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEERROR,
NULL, array('file' => $prefFile)
);
return false;
}
// Close the file.
if (!fclose($fp)) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_PREFFILE_WRITEERROR,
NULL, array('file' => $prefFile)
);
return false;
} else {
return true;
}
}
/**
* Returns whether or not the user's preferences will allow an update to
* take place.
*
* The user's preferences may define restrictions such as:
* - don't update
* - don't ask until next version (remembers last version asked)
* - only ask for state XXXX or higher
* - minor or higher (no bug fix)
* - major only
*
* @access public
* @return boolean true if the preferences will allow an update for the
* latest version.
* @since 0.4.0a1
*/
function preferencesAllowUpdate()
{
// Get the preferences for the package.
$prefs = $this->getPackagePreferences();
// Check to see if the user wants to be notified about any updates for
// this package.
if (isset($prefs[PEAR_PACKAGEUPDATE_PREF_NOUPDATES]) &&
$prefs[PEAR_PACKAGEUPDATE_PREF_NOUPDATES]
) {
return false;
}
// Check to see if the user has requested not to be asked until a new
// version is released.
if (isset($prefs[PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE]) &&
!version_compare($this->latestVersion,
$prefs[PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE],
'>')
) {
return false;
}
// Check to see if the user has requested not to be asked about the
// state of the latest release.
// Create an array of states.
$states = array(PEAR_PACKAGEUPDATE_STATE_DEVEL => 0,
PEAR_PACKAGEUPDATE_STATE_ALPHA => 1,
PEAR_PACKAGEUPDATE_STATE_BETA => 2,
PEAR_PACKAGEUPDATE_STATE_STABLE => 3
);
if (isset($prefs[PEAR_PACKAGEUPDATE_PREF_STATE]) &&
$states[$prefs[PEAR_PACKAGEUPDATE_PREF_STATE]] > $states[$this->info['state']]
) {
return false;
}
// Check to see if the user only wants to be asked about a certain
// type of release (minor|major).
// Create an array for the types of releases.
$releases = array(PEAR_PACKAGEUPDATE_TYPE_BUG => 0,
PEAR_PACKAGEUPDATE_TYPE_MINOR => 1,
PEAR_PACKAGEUPDATE_TYPE_MAJOR => 2
);
if (isset($prefs[PEAR_PACKAGEUPDATE_PREF_TYPE]) &&
$releases[$prefs[PEAR_PACKAGEUPDATE_PREF_TYPE]] > $releases[$this->releaseType()]
) {
return false;
}
// If we got down here, either there are no preferences for this
// package or everything checked out.
return true;
}
/**
* Returns the type of release. (bug|minor|major);
*
* @access protected
* @return string
* @since 0.4.0a1
*/
function releaseType()
{
// Break the two versions into pieces.
$latest = explode('.', $this->latestVersion);
$current = explode('.', $this->instVersion);
if ($latest[0] > $current[0]) {
$type = PEAR_PACKAGEUPDATE_TYPE_MAJOR;
} elseif ($latest[1] > $current[1]) {
$type = PEAR_PACKAGEUPDATE_TYPE_MINOR;
} else {
$type = PEAR_PACKAGEUPDATE_TYPE_BUG;
}
return $type;
}
/**
* Sets the user's preference for asking about all updates for this
* package.
*
* @access public
* @param boolean $dontAsk
* @return boolean true on success, false on failure
* @since 0.4.0a1
*/
function setDontAskAgain($dontAsk)
{
// Make sure the value is a boolean.
settype($dontAsk, 'boolean');
// Set the preference.
return $this->setPreference(PEAR_PACKAGEUPDATE_PREF_NOUPDATES, $dontAsk);
}
/**
* Sets the user's preference for asking about updates again until the next
* release.
*
* @access public
* @param boolean $nextrelease
* @return boolean true on success, false on failure
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_NOINFO
*/
function setDontAskUntilNextRelease($nextrelease)
{
// If nextrelease is true, we have to swap its value out with the
// latest version.
if ($nextrelease) {
// Make sure that the package info was found.
if (empty($this->latestVersion)) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_NOINFO);
return false;
}
$nextrelease = $this->latestVersion;
}
// Set the preference.
return $this->setPreference(PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE,
$nextrelease);
}
/**
* Sets the user's preference for asking about release types.
*
* @access public
* @param string $minType The minimum release type to allow.
* @return boolean true on success, false on failure
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_INVALIDTYPE
*/
function setMinimumReleaseType($minType)
{
// Make sure the type is acceptable.
if ($minType != PEAR_PACKAGEUPDATE_TYPE_BUG &&
$minType != PEAR_PACKAGEUPDATE_TYPE_MINOR &&
$minType != PEAR_PACKAGEUPDATE_TYPE_MAJOR
) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_INVALIDTYPE, NULL,
array('type' => $minType)
);
return false;
}
// Set the preference.
return $this->setPreference(PEAR_PACKAGEUPDATE_PREF_TYPE, $minType);
}
/**
* Sets the user's preference for asking about release states.
*
* @access public
* @param string $minState The minimum release state to allow.
* @return boolean true on success, false on failure
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_INVALIDSTATE
*/
function setMinimumState($minState)
{
// Make sure the type is acceptable.
if ($minState != PEAR_PACKAGEUPDATE_STATE_DEVEL &&
$minState != PEAR_PACKAGEUPDATE_STATE_ALPHA &&
$minState != PEAR_PACKAGEUPDATE_STATE_BETA &&
$minState != PEAR_PACKAGEUPDATE_STATE_STABLE
) {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_INVALIDSTATE, NULL,
array('state' => $minState)
);
return false;
}
// Set the preference.
return $this->setPreference(PEAR_PACKAGEUPDATE_PREF_STATE, $minState);
}
/**
* Sets the given preference to the given value.
*
* Don't take any chances. Anytime a preference is set, the preferences are
* saved. We can't rely on the developer to call savePreferences.
*
* @access protected
* @param integer $pref One of the preference constants.
* @param mixed $value The value of the preference.
* @return boolean true if the preference was set and saved properly.
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_INVALIDPREF
*/
function setPreference($pref, $value)
{
// Make sure the preference is valid.
if ($pref != PEAR_PACKAGEUPDATE_PREF_NOUPDATES &&
$pref != PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE &&
$pref != PEAR_PACKAGEUPDATE_PREF_TYPE &&
$pref != PEAR_PACKAGEUPDATE_PREF_STATE
) {
// Invalid preference!
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_INVALIDPREF, NULL,
array('preference' => $pref)
);
return false;
}
// Make sure the preferences for the channel exist.
if (!isset($this->preferences[$this->channel])) {
$this->preferences[$this->channel] = array();
}
// Make sure the preferences for the package exist.
if (!isset($this->preferences[$this->channel][$this->packageName])) {
$this->preferences[$this->channel][$this->packageName] = array();
}
// Set the preference value.
$this->preferences[$this->channel][$this->packageName][$pref] = $value;
// Save the preferences.
return $this->savePreferences();
}
/**
* Sets all preferences at once.
*
* @access public
* @param array $preferences
* @return boolean true if the preferences were set and saved.
* @since 0.4.0a1
*/
function setPreferences($preferences)
{
// Make sure preferences is an array.
settype($preferences, 'array');
// Make sure there is only valid preference information.
foreach ($preferences as $pref => $value) {
if ($pref != PEAR_PACKAGEUPDATE_PREF_NOUPDATES &&
$pref != PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE &&
$pref != PEAR_PACKAGEUPDATE_PREF_TYPE &&
$pref != PEAR_PACKAGEUPDATE_PREF_STATE
) {
unset($preferences[$pref]);
}
}
// Make sure that next release has the latest release.
if ($preferences[PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE]) {
$preferences[PEAR_PACKAGEUPDATE_PREF_NEXTRELEASE] = $this->latestVersion;
}
// Set the preferences.
$this->preferences[$this->channel][$this->packageName] = $preferences;
// Save the preferences.
return $this->savePreferences();
}
/**
* Updates the source for the package.
*
* We have to update required dependencies automatically to make sure that
* everything still works properly.
*
* It is the developers responsibility to make sure the user is given the
* option to update any optional dependencies if needed. This can be done
* by creating a new instance of PEAR_PackageUpdate for the optional
* dependency.
*
* @access public
* @return boolean true if the update was successful.
* @since 0.4.0a1
* @throws PEAR_PACKAGEUPDATE_ERROR_NOTINSTALLED
*/
function update()
{
// Create a config object.
$config = new PEAR_Config();
// Change the verbosity but keep track of the value to reset it just in
// case this does something permanent.
$verbose = $config->get('verbose');
$config->set('verbose', 0);
// Create a command object to do the upgrade.
// If the current version is 0.0.0 don't upgrade. That would be a
// sneaky way for devs to install packages without the use knowing.
if ($this->instVersion == '0.0.0') {
$this->pushError(PEAR_PACKAGEUPDATE_ERROR_NOTINSTALLED, NULL,
array('packagename' => $this->packageName)
);
return false;
}
require_once 'PEAR/Command.php';
$upgrade = PEAR_Command::factory('upgrade', $config);
// Try to upgrade the application.
$channelPackage = $this->channel . '/' . $this->packageName;
$result = $upgrade->doInstall('upgrade',
array('onlyreqdeps' => true),
array($channelPackage));
// Reset the verbose level just to be safe.
$config->set('verbose', $verbose);
// Check for errors.
if (PEAR::isError($result)) {
$this->pushError($result);
return false;
} else {
return true;
}
}
/**
* Redirects or exits to force the user to restart the application.
*
* @abstract
* @access public
* @return void
* @since 0.4.0a1
*/
function forceRestart()
{
$this->pushError('forceRestart is an abstract method that must be' .
' overridden in the child class.');
}
/**
* Presents the user with the option to update.
*
* @abstract
* @access public
* @return boolean true if the user wants to update
* @since 0.4.0a1
*/
function presentUpdate()
{
$this->pushError('presentUpdate is an abstract method that must be' .
' overridden in the child class.');
// Return false just in case something odd has happened.
return false;
}
/**
* Pushes an error onto an error stack.
*
* This method is just for collecting errors that occur while checking for
* updates and updating a package. The child class is responsible for
* displaying all errors and handling them properly. This is because the
* way errors are handled varies greatly depending on the driver used.
*
* @access public
* @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|Exception
* if compatibility mode is on, a PEAR_Error is
* also thrown. If the class Exception exists,
* then one is returned.
* @since 0.4.0a1
*/
function pushError($code, $level = 'error', $params = array(),
$msg = false, $repackage = false, $backtrace = false)
{
// Check to see if a PEAR_Error was pushed.
if (PEAR::isError($code)) {
return $this->repackagePEAR_Error($code);
}
// Check the arguments to see if just a code was submitted.
if (is_int($code) &&
!(bool) $msg &&
isset($GLOBALS['_PEAR_PACKAGEUPDATE_ERRORS'][$code])
) {
$msg = $GLOBALS['_PEAR_PACKAGEUPDATE_ERRORS'][$code];
}
// Append the error onto the stack.
return $this->errors->push($code, null, $params, $msg,
$repackage, $backtrace
);
}
/**
* Repackages PEAR_Errors for use with ErrorStack.
*
* @author Ian Eure
*
* @access public
* @param object $error A PEAR_Error
* @return mixed The return from PEAR::ErrorStack::push()
* @since 0.4.0a1
*/
function repackagePEAR_Error(&$error)
{
static $map;
if (!isset($map)) {
$map = array(
E_ERROR => 'error',
E_WARNING => 'warning',
E_PARSE => 'exception',
E_NOTICE => 'notice',
E_CORE_ERROR => 'error',
E_CORE_WARNING => 'warning',
E_COMPILE_ERROR => 'exception',
E_COMPILE_WARNING => 'warning',
E_USER_ERROR => 'error',
E_USER_WARNING => 'warning',
E_USER_NOTICE => 'notice'
);
}
// Strip this function from the trace
if (is_array($error->backtrace)) {
array_shift($error->backtrace);
$error->userinfo['backtrace'] =& $error->backtrace;
}
return $this->errors->push($error->code, $map[$error->level],
$error->userinfo, $error->message, false,
$error->backtrace
);
}
/**
* Pops an error off the error stack.
*
* This method is just for collecting errors that occur while checking for
* updates and updating a package. The child class is responsible for
* displaying all errors and handling them properly. This is because the
* way errors are handled varies greatly depending on the driver used.
*
* @access public
* @return object A PEAR_Error instance or false if no errors exist.
* @since 0.4.0a1
*/
function popError()
{
return $this->errors->pop();
}
/**
* Returns whether or not errors have occurred (and been captured).
*
* @access public
* @return boolean
* @since 0.4.0a1
*/
function hasErrors()
{
return $this->errors->hasErrors();
}
}
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
*/
?>
Copy Permalink