TimeTrex Community Edition v16.2.0
This commit is contained in:
19
vendor/pear/cache_lite/.travis.yml
vendored
Normal file
19
vendor/pear/cache_lite/.travis.yml
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
language: php
|
||||
|
||||
before_install:
|
||||
- pear upgrade pear
|
||||
|
||||
install:
|
||||
- pear install package.xml
|
||||
|
||||
php:
|
||||
- 5.4
|
||||
- 5.5
|
||||
- 5.6
|
||||
- 7.0
|
||||
- 7.1
|
||||
- 7.2
|
||||
|
||||
script:
|
||||
- composer install
|
||||
- vendor/bin/phpunit tests/
|
||||
898
vendor/pear/cache_lite/Cache/Lite.php
vendored
Normal file
898
vendor/pear/cache_lite/Cache/Lite.php
vendored
Normal file
@@ -0,0 +1,898 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Fast, light and safe Cache Class
|
||||
*
|
||||
* Cache_Lite is a fast, light and safe cache system. It's optimized
|
||||
* for file containers. It is fast and safe (because it uses file
|
||||
* locking and/or anti-corruption tests).
|
||||
*
|
||||
* There are some examples in the 'docs/examples' file
|
||||
* Technical choices are described in the 'docs/technical' file
|
||||
*
|
||||
* Memory Caching is from an original idea of
|
||||
* Mike BENOIT <ipso@snappymail.ca>
|
||||
*
|
||||
* Nota : A chinese documentation (thanks to RainX <china_1982@163.com>) is
|
||||
* available at :
|
||||
* http://rainx.phpmore.com/manual/cache_lite.html
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @category Caching
|
||||
* @author Fabien MARTY <fab@php.net>
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
define('CACHE_LITE_ERROR_RETURN', 1);
|
||||
define('CACHE_LITE_ERROR_DIE', 8);
|
||||
|
||||
class Cache_Lite
|
||||
{
|
||||
|
||||
// --- Private properties ---
|
||||
|
||||
/**
|
||||
* Directory where to put the cache files
|
||||
* (make sure to add a trailing slash)
|
||||
*
|
||||
* @var string $_cacheDir
|
||||
*/
|
||||
var $_cacheDir = '/tmp/';
|
||||
|
||||
/**
|
||||
* Enable / disable caching
|
||||
*
|
||||
* (can be very usefull for the debug of cached scripts)
|
||||
*
|
||||
* @var boolean $_caching
|
||||
*/
|
||||
var $_caching = true;
|
||||
|
||||
/**
|
||||
* Cache lifetime (in seconds)
|
||||
*
|
||||
* If null, the cache is valid forever.
|
||||
*
|
||||
* @var int $_lifeTime
|
||||
*/
|
||||
var $_lifeTime = 3600;
|
||||
|
||||
/**
|
||||
* Enable / disable fileLocking
|
||||
*
|
||||
* (can avoid cache corruption under bad circumstances)
|
||||
*
|
||||
* @var boolean $_fileLocking
|
||||
*/
|
||||
var $_fileLocking = true;
|
||||
|
||||
/**
|
||||
* Timestamp of the last valid cache
|
||||
*
|
||||
* @var int $_refreshTime
|
||||
*/
|
||||
var $_refreshTime;
|
||||
|
||||
/**
|
||||
* File name (with path)
|
||||
*
|
||||
* @var string $_file
|
||||
*/
|
||||
var $_file;
|
||||
|
||||
/**
|
||||
* File name (without path)
|
||||
*
|
||||
* @var string $_fileName
|
||||
*/
|
||||
var $_fileName;
|
||||
|
||||
/**
|
||||
* Enable / disable write control (the cache is read just after writing to detect corrupt entries)
|
||||
*
|
||||
* Enable write control will lightly slow the cache writing but not the cache reading
|
||||
* Write control can detect some corrupt cache files but maybe it's not a perfect control
|
||||
*
|
||||
* @var boolean $_writeControl
|
||||
*/
|
||||
var $_writeControl = true;
|
||||
|
||||
/**
|
||||
* Enable / disable read control
|
||||
*
|
||||
* If enabled, a control key is embeded in cache file and this key is compared with the one
|
||||
* calculated after the reading.
|
||||
*
|
||||
* @var boolean $_writeControl
|
||||
*/
|
||||
var $_readControl = true;
|
||||
|
||||
/**
|
||||
* Type of read control (only if read control is enabled)
|
||||
*
|
||||
* Available values are :
|
||||
* 'md5' for a md5 hash control (best but slowest)
|
||||
* 'crc32' for a crc32 hash control (lightly less safe but faster, better choice)
|
||||
* 'strlen' for a length only test (fastest)
|
||||
*
|
||||
* @var boolean $_readControlType
|
||||
*/
|
||||
var $_readControlType = 'crc32';
|
||||
|
||||
/**
|
||||
* Pear error mode (when raiseError is called)
|
||||
*
|
||||
* (see PEAR doc)
|
||||
*
|
||||
* @see setToDebug()
|
||||
* @var int $_pearErrorMode
|
||||
*/
|
||||
var $_pearErrorMode = CACHE_LITE_ERROR_RETURN;
|
||||
|
||||
/**
|
||||
* Current cache id
|
||||
*
|
||||
* @var string $_id
|
||||
*/
|
||||
var $_id;
|
||||
|
||||
/**
|
||||
* Current cache group
|
||||
*
|
||||
* @var string $_group
|
||||
*/
|
||||
var $_group;
|
||||
|
||||
/**
|
||||
* Enable / Disable "Memory Caching"
|
||||
*
|
||||
* NB : There is no lifetime for memory caching !
|
||||
*
|
||||
* @var boolean $_memoryCaching
|
||||
*/
|
||||
var $_memoryCaching = false;
|
||||
|
||||
/**
|
||||
* Enable / Disable "Only Memory Caching"
|
||||
* (be carefull, memory caching is "beta quality")
|
||||
*
|
||||
* @var boolean $_onlyMemoryCaching
|
||||
*/
|
||||
var $_onlyMemoryCaching = false;
|
||||
|
||||
/**
|
||||
* Memory caching array
|
||||
*
|
||||
* @var array $_memoryCachingArray
|
||||
*/
|
||||
var $_memoryCachingArray = array();
|
||||
|
||||
/**
|
||||
* Memory caching counter
|
||||
*
|
||||
* @var int $memoryCachingCounter
|
||||
*/
|
||||
var $_memoryCachingCounter = 0;
|
||||
|
||||
/**
|
||||
* Memory caching limit
|
||||
*
|
||||
* @var int $memoryCachingLimit
|
||||
*/
|
||||
var $_memoryCachingLimit = 1000;
|
||||
|
||||
/**
|
||||
* File Name protection
|
||||
*
|
||||
* if set to true, you can use any cache id or group name
|
||||
* if set to false, it can be faster but cache ids and group names
|
||||
* will be used directly in cache file names so be carefull with
|
||||
* special characters...
|
||||
*
|
||||
* @var boolean $fileNameProtection
|
||||
*/
|
||||
var $_fileNameProtection = true;
|
||||
|
||||
/**
|
||||
* Enable / disable automatic serialization
|
||||
*
|
||||
* it can be used to save directly datas which aren't strings
|
||||
* (but it's slower)
|
||||
*
|
||||
* @var boolean $_serialize
|
||||
*/
|
||||
var $_automaticSerialization = false;
|
||||
|
||||
/**
|
||||
* Disable / Tune the automatic cleaning process
|
||||
*
|
||||
* The automatic cleaning process destroy too old (for the given life time)
|
||||
* cache files when a new cache file is written.
|
||||
* 0 => no automatic cache cleaning
|
||||
* 1 => systematic cache cleaning
|
||||
* x (integer) > 1 => automatic cleaning randomly 1 times on x cache write
|
||||
*
|
||||
* @var int $_automaticCleaning
|
||||
*/
|
||||
var $_automaticCleaningFactor = 0;
|
||||
|
||||
/**
|
||||
* Nested directory level
|
||||
*
|
||||
* Set the hashed directory structure level. 0 means "no hashed directory
|
||||
* structure", 1 means "one level of directory", 2 means "two levels"...
|
||||
* This option can speed up Cache_Lite only when you have many thousands of
|
||||
* cache file. Only specific benchs can help you to choose the perfect value
|
||||
* for you. Maybe, 1 or 2 is a good start.
|
||||
*
|
||||
* @var int $_hashedDirectoryLevel
|
||||
*/
|
||||
var $_hashedDirectoryLevel = 0;
|
||||
|
||||
/**
|
||||
* Umask for hashed directory structure
|
||||
*
|
||||
* @var int $_hashedDirectoryUmask
|
||||
*/
|
||||
var $_hashedDirectoryUmask = 0700;
|
||||
|
||||
/**
|
||||
* API break for error handling in CACHE_LITE_ERROR_RETURN mode
|
||||
*
|
||||
* In CACHE_LITE_ERROR_RETURN mode, error handling was not good because
|
||||
* for example save() method always returned a boolean (a PEAR_Error object
|
||||
* would be better in CACHE_LITE_ERROR_RETURN mode). To correct this without
|
||||
* breaking the API, this option (false by default) can change this handling.
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
var $_errorHandlingAPIBreak = false;
|
||||
|
||||
var $_hashedDirectoryGroup = NULL;
|
||||
|
||||
var $_cacheFileMode = NULL;
|
||||
|
||||
var $_cacheFileGroup = NULL;
|
||||
|
||||
// --- Public methods ---
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* $options is an assoc. Available options are :
|
||||
* $options = array(
|
||||
* 'cacheDir' => directory where to put the cache files (string),
|
||||
* 'caching' => enable / disable caching (boolean),
|
||||
* 'lifeTime' => cache lifetime in seconds (int),
|
||||
* 'fileLocking' => enable / disable fileLocking (boolean),
|
||||
* 'writeControl' => enable / disable write control (boolean),
|
||||
* 'readControl' => enable / disable read control (boolean),
|
||||
* 'readControlType' => type of read control 'crc32', 'md5', 'strlen' (string),
|
||||
* 'pearErrorMode' => pear error mode (when raiseError is called) (cf PEAR doc) (int),
|
||||
* 'memoryCaching' => enable / disable memory caching (boolean),
|
||||
* 'onlyMemoryCaching' => enable / disable only memory caching (boolean),
|
||||
* 'memoryCachingLimit' => max nbr of records to store into memory caching (int),
|
||||
* 'fileNameProtection' => enable / disable automatic file name protection (boolean),
|
||||
* 'automaticSerialization' => enable / disable automatic serialization (boolean),
|
||||
* 'automaticCleaningFactor' => distable / tune automatic cleaning process (int),
|
||||
* 'hashedDirectoryLevel' => level of the hashed directory system (int),
|
||||
* 'hashedDirectoryUmask' => umask for hashed directory structure (int),
|
||||
* 'errorHandlingAPIBreak' => API break for better error handling ? (boolean)
|
||||
* 'hashedDirectoryGroup' => group of hashed directory structure (int | string) (see function chgrp)
|
||||
* 'cacheFileMode' => filesystem mode of newly created cache files (int)
|
||||
* 'cacheFileGroup' => group of newly created cache files (int | string) (see function chgrp)
|
||||
* );
|
||||
*
|
||||
* If sys_get_temp_dir() is available and the
|
||||
* 'cacheDir' option is not provided in the
|
||||
* constructor options array its output is used
|
||||
* to determine the suitable temporary directory.
|
||||
*
|
||||
* @see http://de.php.net/sys_get_temp_dir
|
||||
* @see http://pear.php.net/bugs/bug.php?id=18328
|
||||
*
|
||||
* @param array $options options
|
||||
* @access public
|
||||
*/
|
||||
function __construct($options = array(NULL))
|
||||
{
|
||||
foreach($options as $key => $value) {
|
||||
$this->setOption($key, $value);
|
||||
}
|
||||
if (!isset($options['cacheDir']) && function_exists('sys_get_temp_dir')) {
|
||||
$this->setOption('cacheDir', sys_get_temp_dir() . DIRECTORY_SEPARATOR);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PHP4 constructor for backwards compatibility with older code
|
||||
*
|
||||
* @param array $options Options
|
||||
*/
|
||||
function Cache_Lite($options = array(NULL))
|
||||
{
|
||||
self::__construct($options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generic way to set a Cache_Lite option
|
||||
*
|
||||
* see Cache_Lite constructor for available options
|
||||
*
|
||||
* @var string $name name of the option
|
||||
* @var mixed $value value of the option
|
||||
* @access public
|
||||
*/
|
||||
function setOption($name, $value)
|
||||
{
|
||||
$availableOptions = array('errorHandlingAPIBreak', 'hashedDirectoryUmask', 'hashedDirectoryLevel', 'automaticCleaningFactor', 'automaticSerialization', 'fileNameProtection', 'memoryCaching', 'onlyMemoryCaching', 'memoryCachingLimit', 'cacheDir', 'caching', 'lifeTime', 'fileLocking', 'writeControl', 'readControl', 'readControlType', 'pearErrorMode', 'hashedDirectoryGroup', 'cacheFileMode', 'cacheFileGroup');
|
||||
if (in_array($name, $availableOptions)) {
|
||||
$property = '_'.$name;
|
||||
$this->$property = $value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if a cache is available and (if yes) return it
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @param boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
|
||||
* @return string data of the cache (else : false)
|
||||
* @access public
|
||||
*/
|
||||
function get($id, $group = 'default', $doNotTestCacheValidity = false)
|
||||
{
|
||||
$this->_id = $id;
|
||||
$this->_group = $group;
|
||||
$data = false;
|
||||
if ($this->_caching) {
|
||||
$this->_setRefreshTime();
|
||||
$this->_setFileName($id, $group);
|
||||
clearstatcache();
|
||||
if ($this->_memoryCaching) {
|
||||
if (isset($this->_memoryCachingArray[$this->_file])) {
|
||||
if ($this->_automaticSerialization) {
|
||||
return unserialize($this->_memoryCachingArray[$this->_file]);
|
||||
}
|
||||
return $this->_memoryCachingArray[$this->_file];
|
||||
}
|
||||
if ($this->_onlyMemoryCaching) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (($doNotTestCacheValidity) || (is_null($this->_refreshTime))) {
|
||||
if (file_exists($this->_file)) {
|
||||
$data = $this->_read();
|
||||
}
|
||||
} else {
|
||||
if ((file_exists($this->_file)) && (@filemtime($this->_file) > $this->_refreshTime)) {
|
||||
$data = $this->_read();
|
||||
}
|
||||
}
|
||||
if (($data) and ($this->_memoryCaching)) {
|
||||
$this->_memoryCacheAdd($data);
|
||||
}
|
||||
if (($this->_automaticSerialization) and (is_string($data))) {
|
||||
$data = unserialize($data);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Save some data in a cache file
|
||||
*
|
||||
* @param string $data data to put in cache (can be another type than strings if automaticSerialization is on)
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @return boolean true if no problem (else : false or a PEAR_Error object)
|
||||
* @access public
|
||||
*/
|
||||
function save($data, $id = NULL, $group = 'default')
|
||||
{
|
||||
if ($this->_caching) {
|
||||
if ($this->_automaticSerialization) {
|
||||
$data = serialize($data);
|
||||
}
|
||||
if (isset($id)) {
|
||||
$this->_setFileName($id, $group);
|
||||
}
|
||||
if ($this->_memoryCaching) {
|
||||
$this->_memoryCacheAdd($data);
|
||||
if ($this->_onlyMemoryCaching) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if ($this->_automaticCleaningFactor>0 && ($this->_automaticCleaningFactor==1 || mt_rand(1, $this->_automaticCleaningFactor)==1)) {
|
||||
$this->clean(false, 'old');
|
||||
}
|
||||
if ($this->_writeControl) {
|
||||
$res = $this->_writeAndControl($data);
|
||||
if (is_bool($res)) {
|
||||
if ($res) {
|
||||
return true;
|
||||
}
|
||||
// if $res if false, we need to invalidate the cache
|
||||
@touch($this->_file, time() - 2*abs($this->_lifeTime));
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
$res = $this->_write($data);
|
||||
}
|
||||
if (is_object($res)) {
|
||||
// $res is a PEAR_Error object
|
||||
if (!($this->_errorHandlingAPIBreak)) {
|
||||
return false; // we return false (old API)
|
||||
}
|
||||
}
|
||||
return $res;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a cache file
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @param boolean $checkbeforeunlink check if file exists before removing it
|
||||
* @return boolean true if no problem
|
||||
* @access public
|
||||
*/
|
||||
function remove($id, $group = 'default', $checkbeforeunlink = false)
|
||||
{
|
||||
$this->_setFileName($id, $group);
|
||||
if ($this->_memoryCaching) {
|
||||
if (isset($this->_memoryCachingArray[$this->_file])) {
|
||||
unset($this->_memoryCachingArray[$this->_file]);
|
||||
$this->_memoryCachingCounter = $this->_memoryCachingCounter - 1;
|
||||
}
|
||||
if ($this->_onlyMemoryCaching) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if ( $checkbeforeunlink ) {
|
||||
if (!file_exists($this->_file)) return true;
|
||||
}
|
||||
return $this->_unlink($this->_file);
|
||||
}
|
||||
|
||||
/**
|
||||
* Clean the cache
|
||||
*
|
||||
* if no group is specified all cache files will be destroyed
|
||||
* else only cache files of the specified group will be destroyed
|
||||
*
|
||||
* @param string $group name of the cache group
|
||||
* @param string $mode flush cache mode : 'old', 'ingroup', 'notingroup',
|
||||
* 'callback_myFunction'
|
||||
* @return boolean true if no problem
|
||||
* @access public
|
||||
*/
|
||||
function clean($group = false, $mode = 'ingroup')
|
||||
{
|
||||
return $this->_cleanDir($this->_cacheDir, $group, $mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set to debug mode
|
||||
*
|
||||
* When an error is found, the script will stop and the message will be displayed
|
||||
* (in debug mode only).
|
||||
*
|
||||
* @access public
|
||||
*/
|
||||
function setToDebug()
|
||||
{
|
||||
$this->setOption('pearErrorMode', CACHE_LITE_ERROR_DIE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a new life time
|
||||
*
|
||||
* @param int $newLifeTime new life time (in seconds)
|
||||
* @access public
|
||||
*/
|
||||
function setLifeTime($newLifeTime)
|
||||
{
|
||||
$this->_lifeTime = $newLifeTime;
|
||||
$this->_setRefreshTime();
|
||||
}
|
||||
|
||||
/**
|
||||
* Save the state of the caching memory array into a cache file cache
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @access public
|
||||
*/
|
||||
function saveMemoryCachingState($id, $group = 'default')
|
||||
{
|
||||
if ($this->_caching) {
|
||||
$array = array(
|
||||
'counter' => $this->_memoryCachingCounter,
|
||||
'array' => $this->_memoryCachingArray
|
||||
);
|
||||
$data = serialize($array);
|
||||
$this->save($data, $id, $group);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the state of the caching memory array from a given cache file cache
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @param boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
|
||||
* @access public
|
||||
*/
|
||||
function getMemoryCachingState($id, $group = 'default', $doNotTestCacheValidity = false)
|
||||
{
|
||||
if ($this->_caching) {
|
||||
if ($data = $this->get($id, $group, $doNotTestCacheValidity)) {
|
||||
$array = unserialize($data);
|
||||
$this->_memoryCachingCounter = $array['counter'];
|
||||
$this->_memoryCachingArray = $array['array'];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the cache last modification time
|
||||
*
|
||||
* BE CAREFUL : THIS METHOD IS FOR HACKING ONLY !
|
||||
*
|
||||
* @return int last modification time
|
||||
*/
|
||||
function lastModified()
|
||||
{
|
||||
return @filemtime($this->_file);
|
||||
}
|
||||
|
||||
/**
|
||||
* Trigger a PEAR error
|
||||
*
|
||||
* To improve performances, the PEAR.php file is included dynamically.
|
||||
* The file is so included only when an error is triggered. So, in most
|
||||
* cases, the file isn't included and perfs are much better.
|
||||
*
|
||||
* @param string $msg error message
|
||||
* @param int $code error code
|
||||
* @access public
|
||||
*/
|
||||
function raiseError($msg, $code)
|
||||
{
|
||||
include_once('PEAR.php');
|
||||
return PEAR::raiseError($msg, $code, $this->_pearErrorMode);
|
||||
}
|
||||
|
||||
/**
|
||||
* Extend the life of a valid cache file
|
||||
*
|
||||
* see http://pear.php.net/bugs/bug.php?id=6681
|
||||
*
|
||||
* @access public
|
||||
*/
|
||||
function extendLife()
|
||||
{
|
||||
@touch($this->_file);
|
||||
}
|
||||
|
||||
// --- Private methods ---
|
||||
|
||||
/**
|
||||
* Compute & set the refresh time
|
||||
*
|
||||
* @access private
|
||||
*/
|
||||
function _setRefreshTime()
|
||||
{
|
||||
if (is_null($this->_lifeTime)) {
|
||||
$this->_refreshTime = null;
|
||||
} else {
|
||||
$this->_refreshTime = time() - $this->_lifeTime;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a file
|
||||
*
|
||||
* @param string $file complete file path and name
|
||||
* @return boolean true if no problem
|
||||
* @access private
|
||||
*/
|
||||
function _unlink($file)
|
||||
{
|
||||
if (!@unlink($file)) {
|
||||
return $this->raiseError('Cache_Lite : Unable to remove cache !', -3);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursive function for cleaning cache file in the given directory
|
||||
*
|
||||
* @param string $dir directory complete path (with a trailing slash)
|
||||
* @param string $group name of the cache group
|
||||
* @param string $mode flush cache mode : 'old', 'ingroup', 'notingroup',
|
||||
'callback_myFunction'
|
||||
* @return boolean true if no problem
|
||||
* @access private
|
||||
*/
|
||||
function _cleanDir($dir, $group = false, $mode = 'ingroup')
|
||||
{
|
||||
if ($this->_fileNameProtection) {
|
||||
$motif = ($group) ? 'cache_'.md5($group).'_' : 'cache_';
|
||||
} else {
|
||||
$motif = ($group) ? 'cache_'.$group.'_' : 'cache_';
|
||||
}
|
||||
if ($this->_memoryCaching) {
|
||||
foreach($this->_memoryCachingArray as $key => $v) {
|
||||
if (strpos($key, $motif) !== false) {
|
||||
unset($this->_memoryCachingArray[$key]);
|
||||
$this->_memoryCachingCounter = $this->_memoryCachingCounter - 1;
|
||||
}
|
||||
}
|
||||
if ($this->_onlyMemoryCaching) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (!($dh = @opendir($dir))) {
|
||||
return $this->raiseError('Cache_Lite : Unable to open cache directory !', -4);
|
||||
}
|
||||
$result = true;
|
||||
while (($file = readdir($dh)) !== false) {
|
||||
if (($file != '.') && ($file != '..')) {
|
||||
if (substr($file, 0, 6)=='cache_') {
|
||||
$file2 = $dir . $file;
|
||||
if (is_file($file2)) {
|
||||
switch (substr($mode, 0, 9)) {
|
||||
case 'old':
|
||||
// files older than lifeTime get deleted from cache
|
||||
if (!is_null($this->_lifeTime)) {
|
||||
if ((time() - @filemtime($file2)) > $this->_lifeTime) {
|
||||
$result = ($result and ($this->_unlink($file2)));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 'notingrou':
|
||||
if (strpos($file2, $motif) === false) {
|
||||
$result = ($result and ($this->_unlink($file2)));
|
||||
}
|
||||
break;
|
||||
case 'callback_':
|
||||
$func = substr($mode, 9, strlen($mode) - 9);
|
||||
if ($func($file2, $group)) {
|
||||
$result = ($result and ($this->_unlink($file2)));
|
||||
}
|
||||
break;
|
||||
case 'ingroup':
|
||||
default:
|
||||
if (strpos($file2, $motif) !== false) {
|
||||
$result = ($result and ($this->_unlink($file2)));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ((is_dir($file2)) and ($this->_hashedDirectoryLevel>0)) {
|
||||
$result = ($result and ($this->_cleanDir($file2 . '/', $group, $mode)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Touch the cache file while are recreating it to avoid
|
||||
* launch this task more then once when necessary
|
||||
* When the cache recreated and Added in Cache Memory
|
||||
* @return void
|
||||
* @access private
|
||||
*/
|
||||
function _touchCacheFile(){
|
||||
if (file_exists($this->_file)) {
|
||||
@touch($this->_file);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Add some date in the memory caching array
|
||||
*
|
||||
* @param string $data data to cache
|
||||
* @access private
|
||||
*/
|
||||
function _memoryCacheAdd($data)
|
||||
{
|
||||
$this->_touchCacheFile();
|
||||
$this->_memoryCachingArray[$this->_file] = $data;
|
||||
if ($this->_memoryCachingCounter >= $this->_memoryCachingLimit) {
|
||||
$key = key($this->_memoryCachingArray);
|
||||
next($this->_memoryCachingArray);
|
||||
unset($this->_memoryCachingArray[$key]);
|
||||
|
||||
} else {
|
||||
$this->_memoryCachingCounter = $this->_memoryCachingCounter + 1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Make a file name (with path)
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the group
|
||||
* @access private
|
||||
*/
|
||||
function _setFileName($id, $group)
|
||||
{
|
||||
|
||||
if ($this->_fileNameProtection) {
|
||||
$suffix = 'cache_'.md5($group).'_'.md5($id);
|
||||
} else {
|
||||
$suffix = 'cache_'.$group.'_'.$id;
|
||||
}
|
||||
$root = $this->_cacheDir;
|
||||
if ($this->_hashedDirectoryLevel>0) {
|
||||
$hash = md5($suffix);
|
||||
for ($i=0 ; $i<$this->_hashedDirectoryLevel ; $i++) {
|
||||
$root = $root . 'cache_' . substr($hash, 0, $i + 1) . '/';
|
||||
}
|
||||
}
|
||||
$this->_fileName = $suffix;
|
||||
$this->_file = $root.$suffix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the cache file and return the content
|
||||
*
|
||||
* @return string content of the cache file (else : false or a PEAR_Error object)
|
||||
* @access private
|
||||
*/
|
||||
function _read()
|
||||
{
|
||||
$fp = @fopen($this->_file, "rb");
|
||||
if ($fp) {
|
||||
if ($this->_fileLocking) @flock($fp, LOCK_SH);
|
||||
clearstatcache();
|
||||
$length = @filesize($this->_file);
|
||||
$mqr = (function_exists('get_magic_quotes_runtime') ? @get_magic_quotes_runtime() : 0);
|
||||
if ($mqr) {
|
||||
set_magic_quotes_runtime(0);
|
||||
}
|
||||
if ($this->_readControl) {
|
||||
$hashControl = @fread($fp, 32);
|
||||
$length = $length - 32;
|
||||
}
|
||||
|
||||
if ($length) {
|
||||
$data = '';
|
||||
// See https://bugs.php.net/bug.php?id=30936
|
||||
// The 8192 magic number is the chunk size used internally by PHP.
|
||||
while(!feof($fp)) $data .= fread($fp, 8192);
|
||||
} else {
|
||||
$data = '';
|
||||
}
|
||||
if ($mqr) {
|
||||
set_magic_quotes_runtime($mqr);
|
||||
}
|
||||
if ($this->_fileLocking) @flock($fp, LOCK_UN);
|
||||
@fclose($fp);
|
||||
if ($this->_readControl) {
|
||||
$hashData = $this->_hash($data, $this->_readControlType);
|
||||
if ($hashData != $hashControl) {
|
||||
if (!(is_null($this->_lifeTime))) {
|
||||
@touch($this->_file, time() - 2*abs($this->_lifeTime));
|
||||
} else {
|
||||
@unlink($this->_file);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
return $this->raiseError('Cache_Lite : Unable to read cache !', -2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write the given data in the cache file
|
||||
*
|
||||
* @param string $data data to put in cache
|
||||
* @return boolean true if ok (a PEAR_Error object else)
|
||||
* @access private
|
||||
*/
|
||||
function _write($data)
|
||||
{
|
||||
if ($this->_hashedDirectoryLevel > 0) {
|
||||
$hash = md5($this->_fileName);
|
||||
$root = $this->_cacheDir;
|
||||
for ($i=0 ; $i<$this->_hashedDirectoryLevel ; $i++) {
|
||||
$root = $root . 'cache_' . substr($hash, 0, $i + 1) . '/';
|
||||
if (!(@is_dir($root))) {
|
||||
if (@mkdir($root))
|
||||
{
|
||||
@chmod($root, $this->_hashedDirectoryUmask);
|
||||
if (! is_null($this->_hashedDirectoryGroup))
|
||||
@chgrp($root, $this->_hashedDirectoryGroup);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// if both _cacheFileMode and _cacheFileGroup is null, then we don't need to call
|
||||
// file_exists (see below: if ($is_newfile) ...)
|
||||
$is_newfile = (! is_null($this->_cacheFileMode) || !is_null($this->_cacheFileGroup))
|
||||
&& ! @file_exists($this->_file);
|
||||
$fp = @fopen($this->_file, "wb");
|
||||
if ($fp) {
|
||||
if ($this->_fileLocking) @flock($fp, LOCK_EX);
|
||||
if ($is_newfile)
|
||||
{
|
||||
if (! is_null($this->_cacheFileMode))
|
||||
@chmod($this->_file, $this->_cacheFileMode);
|
||||
if (! is_null($this->_cacheFileGroup))
|
||||
@chgrp($this->_file, $this->_cacheFileGroup);
|
||||
}
|
||||
if ($this->_readControl) {
|
||||
@fwrite($fp, $this->_hash($data, $this->_readControlType), 32);
|
||||
}
|
||||
$mqr = (function_exists('get_magic_quotes_runtime') ? @get_magic_quotes_runtime() : 0);
|
||||
if ($mqr) {
|
||||
set_magic_quotes_runtime(0);
|
||||
}
|
||||
@fwrite($fp, $data);
|
||||
if ($mqr) {
|
||||
set_magic_quotes_runtime($mqr);
|
||||
}
|
||||
if ($this->_fileLocking) @flock($fp, LOCK_UN);
|
||||
@fclose($fp);
|
||||
return true;
|
||||
}
|
||||
return $this->raiseError('Cache_Lite : Unable to write cache file : '.$this->_file, -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write the given data in the cache file and control it just after to avoir corrupted cache entries
|
||||
*
|
||||
* @param string $data data to put in cache
|
||||
* @return boolean true if the test is ok (else : false or a PEAR_Error object)
|
||||
* @access private
|
||||
*/
|
||||
function _writeAndControl($data)
|
||||
{
|
||||
$result = $this->_write($data);
|
||||
if (is_object($result)) {
|
||||
return $result; # We return the PEAR_Error object
|
||||
}
|
||||
$dataRead = $this->_read();
|
||||
if (is_object($dataRead)) {
|
||||
return $dataRead; # We return the PEAR_Error object
|
||||
}
|
||||
if ((is_bool($dataRead)) && (!$dataRead)) {
|
||||
return false;
|
||||
}
|
||||
return ($dataRead==$data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Make a control key with the string containing datas
|
||||
*
|
||||
* @param string $data data
|
||||
* @param string $controlType type of control 'md5', 'crc32' or 'strlen'
|
||||
* @return string control key
|
||||
* @access private
|
||||
*/
|
||||
function _hash($data, $controlType)
|
||||
{
|
||||
switch ($controlType) {
|
||||
case 'md5':
|
||||
return md5($data);
|
||||
case 'crc32':
|
||||
return sprintf('% 32d', crc32($data));
|
||||
case 'strlen':
|
||||
return sprintf('% 32d', strlen($data));
|
||||
default:
|
||||
return $this->raiseError('Unknown controlType ! (available values are only \'md5\', \'crc32\', \'strlen\')', -5);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
100
vendor/pear/cache_lite/Cache/Lite/File.php
vendored
Normal file
100
vendor/pear/cache_lite/Cache/Lite/File.php
vendored
Normal file
@@ -0,0 +1,100 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This class extends Cache_Lite and offers a cache system driven by a master file
|
||||
*
|
||||
* With this class, cache validity is only dependent of a given file. Cache files
|
||||
* are valid only if they are older than the master file. It's a perfect way for
|
||||
* caching templates results (if the template file is newer than the cache, cache
|
||||
* must be rebuild...) or for config classes...
|
||||
* There are some examples in the 'docs/examples' file
|
||||
* Technical choices are described in the 'docs/technical' file
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @author Fabien MARTY <fab@php.net>
|
||||
*/
|
||||
|
||||
require_once('Cache/Lite.php');
|
||||
|
||||
class Cache_Lite_File extends Cache_Lite
|
||||
{
|
||||
|
||||
// --- Private properties ---
|
||||
|
||||
/**
|
||||
* Complete path of the file used for controlling the cache lifetime
|
||||
*
|
||||
* @var string $_masterFile
|
||||
*/
|
||||
var $_masterFile = '';
|
||||
|
||||
/**
|
||||
* Masterfile mtime
|
||||
*
|
||||
* @var int $_masterFile_mtime
|
||||
*/
|
||||
var $_masterFile_mtime = 0;
|
||||
|
||||
// --- Public methods ----
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* $options is an assoc. To have a look at availables options,
|
||||
* see the constructor of the Cache_Lite class in 'Cache_Lite.php'
|
||||
*
|
||||
* Comparing to Cache_Lite constructor, there is another option :
|
||||
* $options = array(
|
||||
* (...) see Cache_Lite constructor
|
||||
* 'masterFile' => complete path of the file used for controlling the cache lifetime(string)
|
||||
* );
|
||||
*
|
||||
* @param array $options options
|
||||
* @access public
|
||||
*/
|
||||
function __construct($options = array(NULL))
|
||||
{
|
||||
$options['lifetime'] = 0;
|
||||
parent::__construct($options);
|
||||
if (isset($options['masterFile'])) {
|
||||
$this->_masterFile = $options['masterFile'];
|
||||
} else {
|
||||
return $this->raiseError('Cache_Lite_File : masterFile option must be set !');
|
||||
}
|
||||
if (!($this->_masterFile_mtime = @filemtime($this->_masterFile))) {
|
||||
return $this->raiseError('Cache_Lite_File : Unable to read masterFile : '.$this->_masterFile, -3);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* PHP4 constructor for backwards compatibility with older code
|
||||
*
|
||||
* @param array $options Options
|
||||
*/
|
||||
function Cache_Lite_File($options = array(NULL))
|
||||
{
|
||||
self::__construct($options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if a cache is available and (if yes) return it
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @param boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
|
||||
* @return string data of the cache (else : false)
|
||||
* @access public
|
||||
*/
|
||||
function get($id, $group = 'default', $doNotTestCacheValidity = false)
|
||||
{
|
||||
if ($data = parent::get($id, $group, true)) {
|
||||
if ($filemtime = $this->lastModified()) {
|
||||
if ($filemtime > $this->_masterFile_mtime) {
|
||||
return $data;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
218
vendor/pear/cache_lite/Cache/Lite/Function.php
vendored
Normal file
218
vendor/pear/cache_lite/Cache/Lite/Function.php
vendored
Normal file
@@ -0,0 +1,218 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This class extends Cache_Lite and can be used to cache the result and output of functions/methods
|
||||
*
|
||||
* This class is completly inspired from Sebastian Bergmann's
|
||||
* PEAR/Cache_Function class. This is only an adaptation to
|
||||
* Cache_Lite
|
||||
*
|
||||
* There are some examples in the 'docs/examples' file
|
||||
* Technical choices are described in the 'docs/technical' file
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @author Sebastian BERGMANN <sb@sebastian-bergmann.de>
|
||||
* @author Fabien MARTY <fab@php.net>
|
||||
*/
|
||||
|
||||
require_once('Cache/Lite.php');
|
||||
|
||||
class Cache_Lite_Function extends Cache_Lite
|
||||
{
|
||||
|
||||
// --- Private properties ---
|
||||
|
||||
/**
|
||||
* Default cache group for function caching
|
||||
*
|
||||
* @var string $_defaultGroup
|
||||
*/
|
||||
var $_defaultGroup = 'Cache_Lite_Function';
|
||||
|
||||
/**
|
||||
* Don't cache the method call when its output contains the string "NOCACHE"
|
||||
*
|
||||
* if set to true, the output of the method will never be displayed (because the output is used
|
||||
* to control the cache)
|
||||
*
|
||||
* @var boolean $_dontCacheWhenTheOutputContainsNOCACHE
|
||||
*/
|
||||
var $_dontCacheWhenTheOutputContainsNOCACHE = false;
|
||||
|
||||
/**
|
||||
* Don't cache the method call when its result is false
|
||||
*
|
||||
* @var boolean $_dontCacheWhenTheResultIsFalse
|
||||
*/
|
||||
var $_dontCacheWhenTheResultIsFalse = false;
|
||||
|
||||
/**
|
||||
* Don't cache the method call when its result is null
|
||||
*
|
||||
* @var boolean $_dontCacheWhenTheResultIsNull
|
||||
*/
|
||||
var $_dontCacheWhenTheResultIsNull = false;
|
||||
|
||||
/**
|
||||
* Debug the Cache_Lite_Function caching process
|
||||
*
|
||||
* @var boolean $_debugCacheLiteFunction
|
||||
*/
|
||||
var $_debugCacheLiteFunction = false;
|
||||
|
||||
// --- Public methods ----
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* $options is an assoc. To have a look at availables options,
|
||||
* see the constructor of the Cache_Lite class in 'Cache_Lite.php'
|
||||
*
|
||||
* Comparing to Cache_Lite constructor, there is another option :
|
||||
* $options = array(
|
||||
* (...) see Cache_Lite constructor
|
||||
* 'debugCacheLiteFunction' => (bool) debug the caching process,
|
||||
* 'defaultGroup' => default cache group for function caching (string),
|
||||
* 'dontCacheWhenTheOutputContainsNOCACHE' => (bool) don't cache when the function output contains "NOCACHE",
|
||||
* 'dontCacheWhenTheResultIsFalse' => (bool) don't cache when the function result is false,
|
||||
* 'dontCacheWhenTheResultIsNull' => (bool don't cache when the function result is null
|
||||
* );
|
||||
*
|
||||
* @param array $options options
|
||||
* @access public
|
||||
*/
|
||||
function __construct($options = array(NULL))
|
||||
{
|
||||
$availableOptions = array('debugCacheLiteFunction', 'defaultGroup', 'dontCacheWhenTheOutputContainsNOCACHE', 'dontCacheWhenTheResultIsFalse', 'dontCacheWhenTheResultIsNull');
|
||||
foreach ($options as $name => $value) {
|
||||
if (in_array($name, $availableOptions)) {
|
||||
$property = '_'.$name;
|
||||
$this->$property = $value;
|
||||
}
|
||||
}
|
||||
reset($options);
|
||||
parent::__construct($options);
|
||||
}
|
||||
|
||||
/**
|
||||
* PHP4 constructor for backwards compatibility with older code
|
||||
*
|
||||
* @param array $options Options
|
||||
*/
|
||||
function Cache_Lite_Function($options = array(NULL))
|
||||
{
|
||||
self::__construct($options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calls a cacheable function or method (or not if there is already a cache for it)
|
||||
*
|
||||
* Arguments of this method are read with func_get_args. So it doesn't appear
|
||||
* in the function definition. Synopsis :
|
||||
* call('functionName', $arg1, $arg2, ...)
|
||||
* (arg1, arg2... are arguments of 'functionName')
|
||||
*
|
||||
* @return mixed result of the function/method
|
||||
* @access public
|
||||
*/
|
||||
function call()
|
||||
{
|
||||
$arguments = func_get_args();
|
||||
$id = $this->_makeId($arguments);
|
||||
$data = $this->get($id, $this->_defaultGroup);
|
||||
if ($data !== false) {
|
||||
if ($this->_debugCacheLiteFunction) {
|
||||
echo "Cache hit !\n";
|
||||
}
|
||||
$array = unserialize($data);
|
||||
$output = $array['output'];
|
||||
$result = $array['result'];
|
||||
} else {
|
||||
if ($this->_debugCacheLiteFunction) {
|
||||
echo "Cache missed !\n";
|
||||
}
|
||||
ob_start();
|
||||
ob_implicit_flush(false);
|
||||
$target = array_shift($arguments);
|
||||
if (is_array($target)) {
|
||||
// in this case, $target is for example array($obj, 'method')
|
||||
$object = $target[0];
|
||||
$method = $target[1];
|
||||
$result = call_user_func_array(array(&$object, $method), $arguments);
|
||||
} else {
|
||||
if (strstr($target, '::')) { // classname::staticMethod
|
||||
list($class, $method) = explode('::', $target);
|
||||
$result = call_user_func_array(array($class, $method), $arguments);
|
||||
} else if (strstr($target, '->')) { // object->method
|
||||
// use a stupid name ($objet_123456789 because) of problems where the object
|
||||
// name is the same as this var name
|
||||
list($object_123456789, $method) = explode('->', $target);
|
||||
global $$object_123456789;
|
||||
$result = call_user_func_array(array($$object_123456789, $method), $arguments);
|
||||
} else { // function
|
||||
$result = call_user_func_array($target, $arguments);
|
||||
}
|
||||
}
|
||||
$output = ob_get_contents();
|
||||
ob_end_clean();
|
||||
if ($this->_dontCacheWhenTheResultIsFalse) {
|
||||
if ((is_bool($result)) && (!($result))) {
|
||||
echo($output);
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
if ($this->_dontCacheWhenTheResultIsNull) {
|
||||
if (is_null($result)) {
|
||||
echo($output);
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
if ($this->_dontCacheWhenTheOutputContainsNOCACHE) {
|
||||
if (strpos($output, 'NOCACHE') > -1) {
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
$array['output'] = $output;
|
||||
$array['result'] = $result;
|
||||
$this->save(serialize($array), $id, $this->_defaultGroup);
|
||||
}
|
||||
echo($output);
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop a cache file
|
||||
*
|
||||
* Arguments of this method are read with func_get_args. So it doesn't appear
|
||||
* in the function definition. Synopsis :
|
||||
* remove('functionName', $arg1, $arg2, ...)
|
||||
* (arg1, arg2... are arguments of 'functionName')
|
||||
*
|
||||
* @return boolean true if no problem
|
||||
* @access public
|
||||
*/
|
||||
function drop()
|
||||
{
|
||||
$id = $this->_makeId(func_get_args());
|
||||
return $this->remove($id, $this->_defaultGroup);
|
||||
}
|
||||
|
||||
/**
|
||||
* Make an id for the cache
|
||||
*
|
||||
* @var array result of func_get_args for the call() or the remove() method
|
||||
* @return string id
|
||||
* @access private
|
||||
*/
|
||||
function _makeId($arguments)
|
||||
{
|
||||
$id = serialize($arguments); // Generate a cache id
|
||||
if (!$this->_fileNameProtection) {
|
||||
$id = md5($id);
|
||||
// if fileNameProtection is set to false, then the id has to be hashed
|
||||
// because it's a very bad file name in most cases
|
||||
}
|
||||
return $id;
|
||||
}
|
||||
|
||||
}
|
||||
56
vendor/pear/cache_lite/Cache/Lite/NestedOutput.php
vendored
Normal file
56
vendor/pear/cache_lite/Cache/Lite/NestedOutput.php
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This class extends Cache_Lite and uses output buffering to get the data to cache.
|
||||
* It supports nesting of caches
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once('Cache/Lite/Output.php');
|
||||
|
||||
class Cache_Lite_NestedOutput extends Cache_Lite_Output
|
||||
{
|
||||
private $nestedIds = array();
|
||||
private $nestedGroups = array();
|
||||
|
||||
/**
|
||||
* Start the cache
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @param boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
|
||||
* @return boolean|string false if the cache is not hit else the data
|
||||
* @access public
|
||||
*/
|
||||
function start($id, $group = 'default', $doNotTestCacheValidity = false)
|
||||
{
|
||||
$this->nestedIds[] = $id;
|
||||
$this->nestedGroups[] = $group;
|
||||
$data = $this->get($id, $group, $doNotTestCacheValidity);
|
||||
if ($data !== false) {
|
||||
return $data;
|
||||
}
|
||||
ob_start();
|
||||
ob_implicit_flush(false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop the cache
|
||||
*
|
||||
* @param boolen
|
||||
* @return string return contents of cache
|
||||
*/
|
||||
function end()
|
||||
{
|
||||
$data = ob_get_contents();
|
||||
ob_end_clean();
|
||||
$id = array_pop($this->nestedIds);
|
||||
$group = array_pop($this->nestedGroups);
|
||||
$this->save($data, $id, $group);
|
||||
return $data;
|
||||
}
|
||||
|
||||
}
|
||||
78
vendor/pear/cache_lite/Cache/Lite/Output.php
vendored
Normal file
78
vendor/pear/cache_lite/Cache/Lite/Output.php
vendored
Normal file
@@ -0,0 +1,78 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This class extends Cache_Lite and uses output buffering to get the data to cache.
|
||||
*
|
||||
* There are some examples in the 'docs/examples' file
|
||||
* Technical choices are described in the 'docs/technical' file
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @author Fabien MARTY <fab@php.net>
|
||||
*/
|
||||
|
||||
require_once('Cache/Lite.php');
|
||||
|
||||
class Cache_Lite_Output extends Cache_Lite
|
||||
{
|
||||
|
||||
// --- Public methods ---
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* $options is an assoc. To have a look at availables options,
|
||||
* see the constructor of the Cache_Lite class in 'Cache_Lite.php'
|
||||
*
|
||||
* @param array $options options
|
||||
* @access public
|
||||
*/
|
||||
function __construct($options)
|
||||
{
|
||||
parent::__construct($options);
|
||||
}
|
||||
|
||||
/**
|
||||
* PHP4 constructor for backwards compatibility with older code
|
||||
*
|
||||
* @param array $options Options
|
||||
*/
|
||||
function Cache_Lite_Output($options = array(NULL))
|
||||
{
|
||||
self::__construct($options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Start the cache
|
||||
*
|
||||
* @param string $id cache id
|
||||
* @param string $group name of the cache group
|
||||
* @param boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
|
||||
* @return boolean true if the cache is hit (false else)
|
||||
* @access public
|
||||
*/
|
||||
function start($id, $group = 'default', $doNotTestCacheValidity = false)
|
||||
{
|
||||
$data = $this->get($id, $group, $doNotTestCacheValidity);
|
||||
if ($data !== false) {
|
||||
echo($data);
|
||||
return true;
|
||||
}
|
||||
ob_start();
|
||||
ob_implicit_flush(false);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop the cache
|
||||
*
|
||||
* @access public
|
||||
*/
|
||||
function end()
|
||||
{
|
||||
$data = ob_get_contents();
|
||||
ob_end_clean();
|
||||
$this->save($data, $this->_id, $this->_group);
|
||||
echo($data);
|
||||
}
|
||||
|
||||
}
|
||||
458
vendor/pear/cache_lite/LICENSE
vendored
Normal file
458
vendor/pear/cache_lite/LICENSE
vendored
Normal file
@@ -0,0 +1,458 @@
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 2.1, February 1999
|
||||
|
||||
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the Lesser GPL. It also counts
|
||||
as the successor of the GNU Library Public License, version 2, hence
|
||||
the version number 2.1.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Lesser General Public License, applies to some
|
||||
specially designated software packages--typically libraries--of the
|
||||
Free Software Foundation and other authors who decide to use it. You
|
||||
can use it too, but we suggest you first think carefully about whether
|
||||
this license or the ordinary General Public License is the better
|
||||
strategy to use in any particular case, based on the explanations below.
|
||||
|
||||
When we speak of free software, we are referring to freedom of use,
|
||||
not price. Our General Public Licenses are designed to make sure that
|
||||
you have the freedom to distribute copies of free software (and charge
|
||||
for this service if you wish); that you receive source code or can get
|
||||
it if you want it; that you can change the software and use pieces of
|
||||
it in new free programs; and that you are informed that you can do
|
||||
these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
distributors to deny you these rights or to ask you to surrender these
|
||||
rights. These restrictions translate to certain responsibilities for
|
||||
you if you distribute copies of the library or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link other code with the library, you must provide
|
||||
complete object files to the recipients, so that they can relink them
|
||||
with the library after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
We protect your rights with a two-step method: (1) we copyright the
|
||||
library, and (2) we offer you this license, which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
To protect each distributor, we want to make it very clear that
|
||||
there is no warranty for the free library. Also, if the library is
|
||||
modified by someone else and passed on, the recipients should know
|
||||
that what they have is not the original version, so that the original
|
||||
author's reputation will not be affected by problems that might be
|
||||
introduced by others.
|
||||
|
||||
Finally, software patents pose a constant threat to the existence of
|
||||
any free program. We wish to make sure that a company cannot
|
||||
effectively restrict the users of a free program by obtaining a
|
||||
restrictive license from a patent holder. Therefore, we insist that
|
||||
any patent license obtained for a version of the library must be
|
||||
consistent with the full freedom of use specified in this license.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the
|
||||
ordinary GNU General Public License. This license, the GNU Lesser
|
||||
General Public License, applies to certain designated libraries, and
|
||||
is quite different from the ordinary General Public License. We use
|
||||
this license for certain libraries in order to permit linking those
|
||||
libraries into non-free programs.
|
||||
|
||||
When a program is linked with a library, whether statically or using
|
||||
a shared library, the combination of the two is legally speaking a
|
||||
combined work, a derivative of the original library. The ordinary
|
||||
General Public License therefore permits such linking only if the
|
||||
entire combination fits its criteria of freedom. The Lesser General
|
||||
Public License permits more lax criteria for linking other code with
|
||||
the library.
|
||||
|
||||
We call this license the "Lesser" General Public License because it
|
||||
does Less to protect the user's freedom than the ordinary General
|
||||
Public License. It also provides other free software developers Less
|
||||
of an advantage over competing non-free programs. These disadvantages
|
||||
are the reason we use the ordinary General Public License for many
|
||||
libraries. However, the Lesser license provides advantages in certain
|
||||
special circumstances.
|
||||
|
||||
For example, on rare occasions, there may be a special need to
|
||||
encourage the widest possible use of a certain library, so that it becomes
|
||||
a de-facto standard. To achieve this, non-free programs must be
|
||||
allowed to use the library. A more frequent case is that a free
|
||||
library does the same job as widely used non-free libraries. In this
|
||||
case, there is little to gain by limiting the free library to free
|
||||
software only, so we use the Lesser General Public License.
|
||||
|
||||
In other cases, permission to use a particular library in non-free
|
||||
programs enables a greater number of people to use a large body of
|
||||
free software. For example, permission to use the GNU C Library in
|
||||
non-free programs enables many more people to use the whole GNU
|
||||
operating system, as well as its variant, the GNU/Linux operating
|
||||
system.
|
||||
|
||||
Although the Lesser General Public License is Less protective of the
|
||||
users' freedom, it does ensure that the user of a program that is
|
||||
linked with the Library has the freedom and the wherewithal to run
|
||||
that program using a modified version of the Library.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, whereas the latter must
|
||||
be combined with the library in order to run.
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library or other
|
||||
program which contains a notice placed by the copyright holder or
|
||||
other authorized party saying it may be distributed under the terms of
|
||||
this Lesser General Public License (also called "this License").
|
||||
Each licensee is addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control compilation
|
||||
and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also combine or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (1) uses at run time a
|
||||
copy of the library already present on the user's computer system,
|
||||
rather than copying library functions into the executable, and (2)
|
||||
will operate properly with a modified version of the library, if
|
||||
the user installs one, as long as the modified version is
|
||||
interface-compatible with the version that the work was made with.
|
||||
|
||||
c) Accompany the work with a written offer, valid for at
|
||||
least three years, to give the same user the materials
|
||||
specified in Subsection 6a, above, for a charge no more
|
||||
than the cost of performing this distribution.
|
||||
|
||||
d) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
e) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the materials to be distributed need not include anything that is
|
||||
normally distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties with
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under any
|
||||
particular circumstance, the balance of the section is intended to apply,
|
||||
and the section as a whole is intended to apply in other circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License may add
|
||||
an explicit geographical distribution limitation excluding those countries,
|
||||
so that distribution is permitted only in or among countries not thus
|
||||
excluded. In such case, this License incorporates the limitation as if
|
||||
written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Lesser General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
41
vendor/pear/cache_lite/README.md
vendored
Normal file
41
vendor/pear/cache_lite/README.md
vendored
Normal file
@@ -0,0 +1,41 @@
|
||||
# PEAR Cache_Lite
|
||||
|
||||
Fast and safe little cache system.
|
||||
|
||||
This package is a little cache system optimized for file containers.
|
||||
t is fast and safe (because it uses file locking and/or anti-corruption tests).
|
||||
|
||||
[](https://travis-ci.org/pear/Cache_Lite)
|
||||
|
||||
|
||||
## Building
|
||||
To test this package, run
|
||||
|
||||
phpunit tests/
|
||||
|
||||
To build, simply execute
|
||||
|
||||
pear package
|
||||
|
||||
|
||||
## Installation
|
||||
### PEAR
|
||||
To install from scratch
|
||||
|
||||
pear install package.xml
|
||||
|
||||
To upgrade
|
||||
|
||||
pear upgrade -f package.xml
|
||||
|
||||
### Composer
|
||||
|
||||
composer require pear/cache_lite
|
||||
|
||||
|
||||
## Links
|
||||
- Homepage: http://pear.php.net/package/Cache_Lite
|
||||
- Source code: https://github.com/pear/Cache_Lite
|
||||
- Issue tracker: http://pear.php.net/bugs/search.php?cmd=display&package_name[]=Cache_Lite
|
||||
- Unit test status: https://travis-ci.org/pear/Cache_Lite
|
||||
- Packagist: https://packagist.org/packages/pear/cache_lite
|
||||
46
vendor/pear/cache_lite/TODO
vendored
Normal file
46
vendor/pear/cache_lite/TODO
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
|
||||
Patrick O'Lone suggests the following idea which sounds interesting to
|
||||
add as an optional mode of Cache_Lite class.
|
||||
(still not tested in the Cache_Lite context)
|
||||
|
||||
-------------------------------------------------------------------------
|
||||
If you use the flags:
|
||||
|
||||
ignore_user_abort(true);
|
||||
|
||||
$fd = dio_open($szFilename, O_CREATE | O_EXCL | O_TRUNC | O_WRONLY,
|
||||
0644);
|
||||
if (is_resource($fd)) {
|
||||
|
||||
dio_fcntl($fd, F_SETLKW, array('type' => F_WRLCK));
|
||||
dio_write($fd, $szBuffer);
|
||||
dio_fcntl($fd, F_SETLK, array('type' => F_UNLCK));
|
||||
dio_close($fd);
|
||||
|
||||
}
|
||||
|
||||
ignore_user_abort(false);
|
||||
|
||||
Only the first process will attempt to create a file. Additional
|
||||
processes will see that a file already exists (at the system level), and
|
||||
will fail. Another thing to note is that the file descriptor must be
|
||||
opened using dio_open(), and certain features, like fgets() won't work
|
||||
with it. If your just doing a raw write, dio_write() should be just
|
||||
fine. The dio_read() function should be used like:
|
||||
|
||||
$fd = dio_open($szFilename, O_RDONLY|O_NONBLOCK, 0644);
|
||||
if (is_resource($fd)) {
|
||||
|
||||
dio_fcntl($fd, F_SETLKW, array('type' => F_RDLCK));
|
||||
$szBuffer = dio_read($fd, filesize($szFilename));
|
||||
dio_fcntl($fd, F_SETLK, array('type' => F_UNLCK));
|
||||
dio_close($fd);
|
||||
|
||||
}
|
||||
|
||||
You still use locking to ensure that a write process can finish before
|
||||
another attempts to read the file. We also set non-blocking mode in read
|
||||
mode so that multiple readers can access the same resource at the same
|
||||
time. NOTE: Direct I/O support must be compiled into PHP for these
|
||||
features to work (--enable-dio).
|
||||
-------------------------------------------------------------------------
|
||||
38
vendor/pear/cache_lite/composer.json
vendored
Normal file
38
vendor/pear/cache_lite/composer.json
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"name": "pear/cache_lite",
|
||||
"type": "library",
|
||||
"description": "Fast and safe little cache system",
|
||||
"keywords": [
|
||||
"cache"
|
||||
],
|
||||
"homepage": "https://github.com/pear/Cache_Lite",
|
||||
"license": "LGPL-2.1-or-later",
|
||||
"authors": [
|
||||
{
|
||||
"name": "Markus Tacker",
|
||||
"homepage": "http://pear.php.net/user/tacker"
|
||||
},
|
||||
{
|
||||
"name": "Fabien Marty",
|
||||
"homepage": "http://pear.php.net/user/fab"
|
||||
}
|
||||
],
|
||||
"require": {
|
||||
"php": ">=4.0.0"
|
||||
},
|
||||
"autoload": {
|
||||
"classmap": [
|
||||
"Cache/Lite.php"
|
||||
]
|
||||
},
|
||||
"include-path": [
|
||||
"./"
|
||||
],
|
||||
"support": {
|
||||
"issues": "http://pear.php.net/bugs/search.php?cmd=display&package_name[]=Cache_Lite",
|
||||
"source": "https://github.com/pear/Cache_Lite"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "^4"
|
||||
}
|
||||
}
|
||||
254
vendor/pear/cache_lite/docs/examples
vendored
Normal file
254
vendor/pear/cache_lite/docs/examples
vendored
Normal file
@@ -0,0 +1,254 @@
|
||||
A few examples of Cache_Lite using :
|
||||
------------------------------------
|
||||
|
||||
>>> Basic one :
|
||||
|
||||
<?php
|
||||
|
||||
// Include the package
|
||||
require_once('Cache/Lite.php');
|
||||
|
||||
// Set a id for this cache
|
||||
$id = '123';
|
||||
|
||||
// Set a few options
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 3600
|
||||
);
|
||||
|
||||
// Create a Cache_Lite object
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
|
||||
// Test if thereis a valide cache for this id
|
||||
if ($data = $Cache_Lite->get($id)) {
|
||||
|
||||
// Cache hit !
|
||||
// Content is in $data
|
||||
// (...)
|
||||
|
||||
} else { // No valid cache found (you have to make the page)
|
||||
|
||||
// Cache miss !
|
||||
// Put in $data datas to put in cache
|
||||
// (...)
|
||||
$Cache_Lite->save($data);
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
|
||||
|
||||
>>> Usage with blocks
|
||||
(You can use Cache_Lite for caching blocks and not the whole page)
|
||||
|
||||
<?php
|
||||
|
||||
require_once('Cache/Lite.php');
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 3600
|
||||
);
|
||||
|
||||
// Create a Cache_Lite object
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
|
||||
if ($data = $Cache_Lite->get('block1')) {
|
||||
echo($data);
|
||||
} else {
|
||||
$data = 'Data of the block 1';
|
||||
$Cache_Lite->save($data);
|
||||
}
|
||||
|
||||
echo('<br><br>Non cached line !<br><br>');
|
||||
|
||||
if ($data = $Cache_Lite->get('block2')) {
|
||||
echo($data);
|
||||
} else {
|
||||
$data = 'Data of the block 2';
|
||||
$Cache_Lite->save($data);
|
||||
}
|
||||
|
||||
?>
|
||||
|
||||
|
||||
A few examples of Cache_Lite_Output using :
|
||||
-------------------------------------------
|
||||
|
||||
>>> Basic one :
|
||||
|
||||
<?php
|
||||
|
||||
require_once('Cache/Lite/Output.php');
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Output($options);
|
||||
|
||||
if (!($cache->start('123'))) {
|
||||
// Cache missed...
|
||||
for($i=0;$i<1000;$i++) { // Making of the page...
|
||||
echo('0123456789');
|
||||
}
|
||||
$cache->end();
|
||||
}
|
||||
|
||||
?>
|
||||
|
||||
>>> Usage with blocks :
|
||||
(You can use Cache_Lite_Output for caching blocks and not the whole page)
|
||||
|
||||
<?php
|
||||
|
||||
require_once('Cache/Lite/Output.php');
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Output($options);
|
||||
|
||||
if (!($cache->start('block1'))) {
|
||||
// Cache missed...
|
||||
echo('Data of the block 1 !<br>');
|
||||
$cache->end();
|
||||
}
|
||||
|
||||
echo('<br><br>Non cached line !<br><br>');
|
||||
|
||||
if (!($cache->start('block2'))) {
|
||||
// Cache missed...
|
||||
echo('Data of the block 2 !<br>');
|
||||
$cache->end();
|
||||
}
|
||||
|
||||
|
||||
A few examples of Cache_Lite_Function using :
|
||||
---------------------------------------------
|
||||
|
||||
>>> With function :
|
||||
|
||||
<?php
|
||||
|
||||
require_once('Cache/Lite/Function.php');
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
|
||||
$cache->call('function_to_bench', 12, 45);
|
||||
|
||||
function function_to_bench($arg1, $arg2)
|
||||
{
|
||||
echo "This is the output of the function function_to_bench($arg1, $arg2) !<br>";
|
||||
return "This is the result of the function function_to_bench($arg1, $arg2) !<br>";
|
||||
}
|
||||
|
||||
?>
|
||||
|
||||
>>> With method :
|
||||
|
||||
<?php
|
||||
|
||||
require_once('Cache/Lite/Function.php');
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
|
||||
$obj = new bench();
|
||||
$obj->test = 666;
|
||||
|
||||
$cache->call('obj->method_to_bench', 12, 45);
|
||||
|
||||
class bench
|
||||
{
|
||||
var $test;
|
||||
|
||||
function method_to_bench($arg1, $arg2)
|
||||
{
|
||||
echo "\$obj->test = $this->test and this is the output of the method \$obj->method_to_bench($arg1, $arg2) !<br>";
|
||||
return "\$obj->test = $this->test and this is the result of the method \$obj->method_to_bench($arg1, $arg2) !<br>";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
|
||||
>>> With static method :
|
||||
|
||||
<?php
|
||||
|
||||
require_once('Cache/Lite/Function.php');
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
|
||||
$cache->call('bench::static_method_to_bench', 12, 45);
|
||||
|
||||
class bench
|
||||
{
|
||||
var $test;
|
||||
|
||||
function static_method_to_bench($arg1, $arg2) {
|
||||
echo "This is the output of the function static_method_to_bench($arg1, $arg2) !<br>";
|
||||
return "This is the result of the function static_method_to_bench($arg1, $arg2) !<br>";
|
||||
}
|
||||
}
|
||||
|
||||
?>
|
||||
|
||||
>>> IMPORTANT :
|
||||
|
||||
If you try to use Cache_Lite_Function with $this object ($cache->call('this->method',...)
|
||||
for example), have a look first at :
|
||||
|
||||
http://pear.php.net/bugs/bug.php?id=660
|
||||
|
||||
|
||||
A few examples of Cache_Lite_File using :
|
||||
-----------------------------------------
|
||||
|
||||
<?php
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => '/tmp/',
|
||||
'masterFile' => '/home/web/config.xml'
|
||||
);
|
||||
$cache = new Cache_Lite_File($options);
|
||||
|
||||
// Set a id for this cache
|
||||
$id = '123';
|
||||
|
||||
if ($data = $cache->get($id)) {
|
||||
|
||||
// Cache hit !
|
||||
// Content is in $data
|
||||
// (...)
|
||||
|
||||
} else { // No valid cache found (you have to make the page)
|
||||
|
||||
// Cache miss !
|
||||
// Put in $data datas to put in cache
|
||||
// (...)
|
||||
$cache->save($data);
|
||||
|
||||
}
|
||||
|
||||
|
||||
?>
|
||||
28
vendor/pear/cache_lite/docs/technical
vendored
Normal file
28
vendor/pear/cache_lite/docs/technical
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
Technical choices for Cache_Lite...
|
||||
-----------------------------------
|
||||
|
||||
To begin, the main goals of Cache_Lite :
|
||||
- performances
|
||||
- safe use (even on very high traffic or with NFS (file locking doesn't work
|
||||
with NFS))
|
||||
- flexibility (can be used by the end user or as a part of a larger script)
|
||||
|
||||
|
||||
For speed reasons, it has been decided to focus on the file container (the
|
||||
faster one). So, cache is only stored in files. The class is optimized for that.
|
||||
If you want to use a different cache container, have a look to PEAR/Cache.
|
||||
|
||||
For speed reasons too, the class 'Cache_Lite' has do be independant (so no
|
||||
'require_once' at all in 'Cache_Lite.php'). But, a conditional include_once
|
||||
is allowed. For example, when an error is detected, the class include dynamicaly
|
||||
the PEAR base class 'PEAR.php' to be able to use PEAR::raiseError(). But, in
|
||||
most cases, PEAR.php isn't included.
|
||||
|
||||
For the second goal (safe use), there is three (optional) mecanisms :
|
||||
- File Locking : seems to work fine (but not with distributed file system
|
||||
like NFS...)
|
||||
- WriteControl : the cache is read and compared just after being stored
|
||||
(efficient but not perfect)
|
||||
- ReadControl : a control key (crc32(), md5() ou strlen()) is embeded is the
|
||||
cache file and compared just after reading (the most efficient
|
||||
but the slowest)
|
||||
898
vendor/pear/cache_lite/package.xml
vendored
Normal file
898
vendor/pear/cache_lite/package.xml
vendored
Normal file
@@ -0,0 +1,898 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<package packagerversion="1.9.4" 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">
|
||||
<name>Cache_Lite</name>
|
||||
<channel>pear.php.net</channel>
|
||||
<summary>Fast and Safe little cache system</summary>
|
||||
<description>This package is a little cache system optimized for file containers. It is fast and safe (because it
|
||||
uses file locking and/or anti-corruption tests).
|
||||
</description>
|
||||
<lead>
|
||||
<name>Fabien MARTY</name>
|
||||
<user>fab</user>
|
||||
<email>fab@php.net</email>
|
||||
<active>no</active>
|
||||
</lead>
|
||||
<lead>
|
||||
<name>Markus Tacker</name>
|
||||
<user>tacker</user>
|
||||
<email>tacker@php.net</email>
|
||||
<active>no</active>
|
||||
</lead>
|
||||
<date>2019-11-19</date>
|
||||
<version>
|
||||
<release>1.8.3</release>
|
||||
<api>1.8.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
* PR #8: Fix failing CI
|
||||
* PR #9: Add PHP 7.1 and 7.2 to run PHPUnit on Travis
|
||||
* PR #10: fix(Lite): make _memoryCacheAdd not clear whole cache if limit reached
|
||||
* PR #11: fix get_magic_quotes_runtime is deprecated
|
||||
</notes>
|
||||
<contents>
|
||||
<dir baseinstalldir="/" name="/">
|
||||
<file baseinstalldir="/" name="/Cache/Lite.php" role="php"/>
|
||||
<file baseinstalldir="/" name="/Cache/Lite/File.php" role="php"/>
|
||||
<file baseinstalldir="/" name="/Cache/Lite/Function.php" role="php"/>
|
||||
<file baseinstalldir="/" name="/Cache/Lite/NestedOutput.php" role="php"/>
|
||||
<file baseinstalldir="/" name="/Cache/Lite/Output.php" role="php"/>
|
||||
<file baseinstalldir="/" name="/docs/examples" role="doc"/>
|
||||
<file baseinstalldir="/" name="/docs/technical" role="doc"/>
|
||||
<file baseinstalldir="/" name="LICENSE" role="doc"/>
|
||||
<file baseinstalldir="/" name="README.md" role="doc"/>
|
||||
<file baseinstalldir="/" name="TODO" role="doc"/>
|
||||
<file baseinstalldir="/" name="/tests/bench.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/bench2.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/bench3.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_automaticCleaning.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/cache_lite_base.inc" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_classical.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_error.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_error2.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_eternal.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_fatest.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/cache_lite_file_base.inc" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_File_classical.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/cache_lite_function_base.inc" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_Function_classical.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_Function_dontcache.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_Function_drop.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_hashed.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_lifetime.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_memorycache.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/cache_lite_output_base.inc" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_Output_classical.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/Cache_Lite_serialization.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/callcache.inc" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/NestedOutputTest.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/pearbug513.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/pearbug7618.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/pearbug13693.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/pearbug18192.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/pearbug18328.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/pearbug19422.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/pearbug19711.phpt" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/readme" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/tmpdir.inc" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/ErrorDieTest.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/errordie.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/tests/bootstrap.php" role="test"/>
|
||||
<file baseinstalldir="/" name="/phpunit.xml.dist" role="test"/>
|
||||
</dir>
|
||||
</contents>
|
||||
<dependencies>
|
||||
<required>
|
||||
<php>
|
||||
<min>5.4.0</min>
|
||||
</php>
|
||||
<pearinstaller>
|
||||
<min>1.5.4</min>
|
||||
</pearinstaller>
|
||||
<package>
|
||||
<name>PEAR</name>
|
||||
<channel>pear.php.net</channel>
|
||||
<min>1.10.1</min>
|
||||
</package>
|
||||
</required>
|
||||
</dependencies>
|
||||
<phprelease/>
|
||||
<changelog>
|
||||
<release>
|
||||
<version>
|
||||
<release>0.1</release>
|
||||
<api>0.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2002-08-08</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
This is the first release.
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>0.1.1</release>
|
||||
<api>0.1.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2002-08-08</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
A little packaging fix
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>0.2.0</release>
|
||||
<api>0.2.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2002-08-10</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- Adding Cache_Lite_Function (to cache the result and output of functions/methods)
|
||||
Bugs fixed :
|
||||
- In a few cases of cache corruption, it was possible to get some warnings (but the output was correct)
|
||||
- Cache_Lite_Output require_once (to load Cache_Lite) wasn't correct
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>0.3</release>
|
||||
<api>0.3</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2002-08-31</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- Add '$doNotTestCacheValidity' optional parameter for the get() method
|
||||
Changes :
|
||||
- raiseError() method becomes public
|
||||
- swap of two lines in _write() method (Thanks to Jean-Francois BUSTARRET)
|
||||
Bugs fixed :
|
||||
- remove blank spaces at the end of the class (Thanks to Jean-Francois BUSTARRET)
|
||||
- E_NOTICEs problems and maybe a minor bug of errors management (Thanks to Sebastian BERGMANN)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>0.4</release>
|
||||
<api>0.4</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2002-09-25</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- Add setLifeTime() method to change the cache lifetime dynamicaly
|
||||
Changes :
|
||||
- changes in the directory layout and in file names to (better) respect PEAR standards
|
||||
=> incompatibility with 0.3 version even there is no incompatible change in the API
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.0</release>
|
||||
<api>1.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2002-11-11</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
This is the first stable release of Cache_Lite. There is no big change since the
|
||||
0.4 beta release but two months of tests !
|
||||
Changes :
|
||||
- fix magic_q issue (Thanks to Moshe Doron)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.0.1</release>
|
||||
<api>1.0.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2002-11-12</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bug fixed :
|
||||
- clean() bug with group (Thanks to Ondrej Jombik)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.1</release>
|
||||
<api>1.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2003-02-23</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Changes :
|
||||
- Move to usage of call_user_func_array() and call_user_func() as call_user_method() is depreciated
|
||||
(thanks to Sterling Hughes)
|
||||
New Features :
|
||||
- Introduce memoryCaching (idea of Mike Benoit)
|
||||
- Add of a file name protection option (can be faster if set to off) (thanks to Brian Webb for the idea)
|
||||
Bug fixed :
|
||||
- Little fix : cache was inefficient if the output is only 0 (thanks to Brian Webb)
|
||||
- notice fix (thanks to Lorenzo Alberton, Pierre-Alain Joye and Jon Parise)
|
||||
- Little fix to avoid file names problems with an exotic group name (thanks to Brian Webb)
|
||||
- Fix a possible bug when resave a cache file after a succesfull get (thanks to Michael Caplan)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.2</release>
|
||||
<api>1.2</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2003-10-25</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Changes :
|
||||
- Rewrite of Cache_Lite constructor (thanks to Brian E. Lozier)
|
||||
New Features :
|
||||
- Add of lastModified() method (for Cache_Lite hackers) (thanks to Harry Fuecks)
|
||||
- Introduce automatic serialization (false in default) (thanks to Dan Wilson)
|
||||
- Add of an url for a cache_lite tutorial (english (thanks to paj) and french)
|
||||
Bug fixed :
|
||||
- Change the Cache_Lite::raiseError calls in $this->raiseError (thanks to Holger Willenborg)
|
||||
- Set the default group for remove, since get and save both have it set (thanks to jellybob)
|
||||
- Little fix for caching binary data under Windows (thanks to Simeon Franklin)
|
||||
- little fix with fileNameProtection set to false (not the default (big thank to Harry Fuecks))
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.3</release>
|
||||
<api>1.3</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2004-02-07</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Changes :
|
||||
- Add a warning in examples file because of http://pear.php.net/bugs/bug.php?id=660
|
||||
Bug fixed :
|
||||
- little warning fix in Cache_Lite_Function (fab)
|
||||
- little bug fix in lastModified() method (thanks to Yavor Shahpasov)
|
||||
- fix http://pear.php.net/bugs/bug.php?id=513 (thanks to alan@aardwolfweb.com)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.3.1</release>
|
||||
<api>1.3.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2004-08-16</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bug fixed :
|
||||
- problem with clean() method with memoryCaching activated (thanks to Bojan Mihelac (bmihelac at mihelac
|
||||
dot org))
|
||||
- remove() method didn't deal with memoryCaching
|
||||
- bug fix #1758, thanks to Dave (djpenton at cs dot mu dot oz dot au)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.4.0beta1</release>
|
||||
<api>1.4.0beta1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2004-12-11</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- hashed cache directory structure with the choice of the level (thanks to Mike Benoit (ipso at
|
||||
snappymail dot ca))
|
||||
- new options for cleaning the cache ("not in group", "too old"...) (thanks to
|
||||
dontilooksweetandinnocent@ambience.ru)
|
||||
- automatic cleaning of too old cache files based on a customisable "random method"
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.4.0</release>
|
||||
<api>1.4.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2005-01-21</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Changes :
|
||||
- juste a little more docs since 1.4.0beta1
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.4.1</release>
|
||||
<api>1.4.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2005-03-01</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bug fixed :
|
||||
- problem of non-ISO-8859-1 characters in package.xml (bug #3621)
|
||||
- problem of the returning value in clean() method (integer and not void)
|
||||
(thanks to Demian Turner (demian (at) phpkitchen (dot) com))
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.5.0</release>
|
||||
<api>1.5.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2005-06-18</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- add of a doNotTestCacheValidity in Output (like in Lite.php)
|
||||
- request #4502 : better control on cache cleaning condition (thanks to
|
||||
vincent lascaux); introduce the idea of a user callback for the
|
||||
cleaning process
|
||||
- new Cache_Lite_File module (for a cache controlled by a master file,
|
||||
very usefull for templates or config caching)
|
||||
Bug fixed :
|
||||
- avoid a potential error message if cache doesn't exist
|
||||
- bug #4236 : fread PHP warning on zero length read (because of the change
|
||||
of fread() behaviour in PHP) (thanks to rick dot overman at gmail dot com)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.5.1</release>
|
||||
<api>1.5.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2005-07-10</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Changes :
|
||||
- juste a little more docs since 1.5.0 (beta)
|
||||
- the state in "stable" now
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.5.2</release>
|
||||
<api>1.5.2</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2005-07-18</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bug Fixed :
|
||||
- a "package.xml" problem (a file was forgotten)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.6.0beta1</release>
|
||||
<api>1.6.0beta1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2005-11-17</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- phpt test scripts
|
||||
- add of drop() method to Cache_Lite_Function (thanks to
|
||||
Hugo Morganho hjm at holos dot pt)
|
||||
- request #5495 : a null lifetime give an eternal caching (need tests)
|
||||
Bug fixed :
|
||||
- bugfix #5921 : a variable was unused (no consequence for the end user),
|
||||
thanks to moosh at php dot net
|
||||
- bugfix #5938 : little mistakes given by Zend Code Analyser
|
||||
- little mistake in the example for Cache_Lite_File
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.6.0beta2</release>
|
||||
<api>1.6.0beta2</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2005-11-25</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- a new phpt test script (eternal caching)
|
||||
- you can now call Cache_Lite constructor with any argument (thanks to ratibus at gmail dot com)
|
||||
Bug fixed :
|
||||
- bugfixes about eternal caching
|
||||
Other change :
|
||||
- better code factoring (thanks to ratibus at gmail dot com)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.6.0</release>
|
||||
<api>1.6.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2005-12-03</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
No change (just some modifications into online documentation)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.0beta1</release>
|
||||
<api>1.7.0beta1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2006-01-29</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
New features :
|
||||
- 3 new unit tests
|
||||
- a new option is available in the constructor "errorHandlingAPIBreak" (boolean, false by
|
||||
default) ;
|
||||
if set to true, it introduces a little API break but the error handling is better in
|
||||
CACHE_LITE_ERROR_RETURN
|
||||
mode (specially with the save() method which can return a PEAR_Error object)
|
||||
Changes :
|
||||
- code refactoring for setToDebug() (thanks to moosh (at) php (dot) net)
|
||||
- code refactoring (thanks to code analyzer)
|
||||
Bugs fixed :
|
||||
- #6388 : add an explicit dependancy on PEAR package (for error handling) (thanks to moosh (at) php
|
||||
(dot) net)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.0beta2</release>
|
||||
<api>1.7.0beta2</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>beta</release>
|
||||
<api>beta</api>
|
||||
</stability>
|
||||
<date>2006-02-04</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bugs fixed :
|
||||
- 3 unit test files was forgotten in beta1 package.xml
|
||||
New features :
|
||||
- request #6681 : new extendLife() method (thanks to alex at vegagames dot net)
|
||||
- request #6617 : "$this->method()" calls are ok with Cache_Lite_Function without
|
||||
workaround
|
||||
(thanks to thomas dot nicolai at unisg dot ch)
|
||||
- request #6575 : new options 'dontCacheWhenTheOutputContainsNOCACHE', 'dontCacheWhenTheResultIsFalse',
|
||||
'dontCacheWhenTheResultIsNull' (thanks to thomas dot nicolai at unisg dot ch)
|
||||
- new debug option for Cache_Lite_Function
|
||||
- new test files
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.0</release>
|
||||
<api>1.7.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2006-02-21</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
No change (just some modifications into online documentation)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.1</release>
|
||||
<api>1.7.1</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2006-05-14</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bugs fixed :
|
||||
- #7618 : can't save cache correctly (in some particular cases)
|
||||
(thanks to neta-master at ywcafe dot net)
|
||||
Other changes :
|
||||
- new unit test file (about bug #7618)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.2</release>
|
||||
<api>1.7.2</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2006-06-03</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bugs fixed :
|
||||
- #7799 : setToDebug() doesn't work
|
||||
- #7732 (or #7598) : hashedDirectory refactoring to get rid of some warnings (in some particular cases)
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.3</release>
|
||||
<api>1.7.2</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2008-04-13</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bugs fixed :
|
||||
- #11224 Fixed improper use of strpos
|
||||
- #11260 Fixed improper use of internal property resulting in memory cache not beeing saved
|
||||
- #12750 Fxied internal cleaning routine
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.4</release>
|
||||
<api>1.7.4</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2008-06-08</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Implemented feature request:
|
||||
- #13693 Added new option to Cache_Lite::remove() to check for non-existing cache files.
|
||||
- Added unit test file for Bug #13693
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2009-01-13</date>
|
||||
<version>
|
||||
<release>1.7.5</release>
|
||||
<api>1.7.4</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Bug #7446 - use time() instead if mktime() to prevent a strict error beeing raised.
|
||||
- Request #11766 - Use mt_rand() instead of rand()
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2009-01-25</date>
|
||||
<time>00:00:00</time>
|
||||
<version>
|
||||
<release>1.7.6</release>
|
||||
<api>1.7.4</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Changed PEAR dependency to 1.5.4. See http://pear.php.net/advisory-20070507.txt
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2009-03-07</date>
|
||||
<time>00:00:00</time>
|
||||
<version>
|
||||
<release>1.7.7</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Fixing definition of Cache_Lite_File::get(). See Bug #15986.
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2009-07-07</date>
|
||||
<time>00:00:00</time>
|
||||
<version>
|
||||
<release>1.7.8</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Set magic quotes runtime only if needed. See Bug #15725.
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2011-03-02</date>
|
||||
<time>12:00:00</time>
|
||||
<version>
|
||||
<release>1.7.9</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- If sys_get_temp_dir() is available and the 'cacheDir' option is not provided in the
|
||||
constructor options array its output is used to determine the suitable temporary directory. See Bug
|
||||
#18328
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2011-05-29</date>
|
||||
<time>12:00:00</time>
|
||||
<version>
|
||||
<release>1.7.10</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Updated LICENSE to include "new" address of FSF. Fixes PEAR Bug #18571. Props to Remi Collet
|
||||
for reporting.
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2011-05-30</date>
|
||||
<time>12:00:00</time>
|
||||
<version>
|
||||
<release>1.7.11</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Updated LICENSE to include "new" address of FSF. Fixes PEAR Bug #18571. Props to Remi Collet
|
||||
for reporting.
|
||||
- Updated links to LGPL in package.xml
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.12</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2011-11-15</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Fixes PEAR Bug #18679. Props to Tama Pugsley for reporting.
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.13</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2011-11-15</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
Bug #18965 Tests fail with current dir structure
|
||||
Bug #18987 Remove error_reporting
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<version>
|
||||
<release>1.7.14</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<date>2012-05-21</date>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Fixes PEAR Bug #19422. Props to Fletcher Moore for reporting.
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2012-05-24</date>
|
||||
<time>12:00:00</time>
|
||||
<version>
|
||||
<release>1.7.15</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Fixes Bug #19434: Bad roles for test and doc files. Props to Remi Collet for reporting.
|
||||
</notes>
|
||||
</release>
|
||||
<release>
|
||||
<date>2014-05-10</date>
|
||||
<time>12:00:00</time>
|
||||
<version>
|
||||
<release>1.7.16</release>
|
||||
<api>1.7.7</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Update tests to work with PHPUnit4
|
||||
</notes>
|
||||
</release>
|
||||
|
||||
<release>
|
||||
<date>2016-07-04</date>
|
||||
<time>07:00:00</time>
|
||||
<version>
|
||||
<release>1.8.0</release>
|
||||
<api>1.8.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Add PHP5-style constructors, but keep PHP4 ones for BC
|
||||
- Make non-static test method static
|
||||
- Raise minimum PEAR version to 1.10.1
|
||||
- Raise minimum PHP version to 5.4
|
||||
</notes>
|
||||
</release>
|
||||
|
||||
<release>
|
||||
<date>2018-01-27</date>
|
||||
<version>
|
||||
<release>1.8.1</release>
|
||||
<api>1.8.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Use correct SPDX license identifier
|
||||
</notes>
|
||||
</release>
|
||||
|
||||
<release>
|
||||
<date>2018-02-13</date>
|
||||
<version>
|
||||
<release>1.8.2</release>
|
||||
<api>1.8.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
- Bug #21003 "PHP7: Cache_Lite has a deprecated constructor"
|
||||
- Bug #21231 "The each() function is deprecated in PHP7.2"
|
||||
</notes>
|
||||
</release>
|
||||
|
||||
<release>
|
||||
<date>2019-11-19</date>
|
||||
<version>
|
||||
<release>1.8.3</release>
|
||||
<api>1.8.0</api>
|
||||
</version>
|
||||
<stability>
|
||||
<release>stable</release>
|
||||
<api>stable</api>
|
||||
</stability>
|
||||
<license uri="http://www.gnu.org/licenses/lgpl-2.1.html">lgpl</license>
|
||||
<notes>
|
||||
* PR #8: Fix failing CI
|
||||
* PR #9: Add PHP 7.1 and 7.2 to run PHPUnit on Travis
|
||||
* PR #10: fix(Lite): make _memoryCacheAdd not clear whole cache if limit reached
|
||||
* PR #11: fix get_magic_quotes_runtime is deprecated
|
||||
</notes>
|
||||
</release>
|
||||
</changelog>
|
||||
</package>
|
||||
2
vendor/pear/cache_lite/phpunit.xml.dist
vendored
Normal file
2
vendor/pear/cache_lite/phpunit.xml.dist
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
<phpunit bootstrap="./tests/bootstrap.php">
|
||||
</phpunit>
|
||||
92
vendor/pear/cache_lite/tests/Cache_Lite_File_classical.phpt
vendored
Normal file
92
vendor/pear/cache_lite/tests/Cache_Lite_File_classical.phpt
vendored
Normal file
@@ -0,0 +1,92 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite_File (classical)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_file_base.inc';
|
||||
|
||||
$master = tmpDir() . '/' . 'foobar.masterfile';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'masterFile' => $master
|
||||
);
|
||||
|
||||
$f = fopen($master, 'w');
|
||||
fwrite($f, 'foobar');
|
||||
fclose($f);
|
||||
sleep(1);
|
||||
|
||||
$Cache_Lite = new Cache_Lite_File($options);
|
||||
multipleCallCache('string');
|
||||
multipleCallCache3_1('string');
|
||||
|
||||
echo "==> We touch masterFile\n";
|
||||
touch($master);
|
||||
sleep(1);
|
||||
clearstatcache();
|
||||
echo "\nDone !\n\n";
|
||||
$Cache_Lite = new Cache_Lite_File($options);
|
||||
sleep(1);
|
||||
multipleCallCache3_2('string');
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
==> #6 call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #7 call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We touch masterFile
|
||||
|
||||
Done !
|
||||
|
||||
==> #8 call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
102
vendor/pear/cache_lite/tests/Cache_Lite_Function_classical.phpt
vendored
Normal file
102
vendor/pear/cache_lite/tests/Cache_Lite_Function_classical.phpt
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite_Function (classical)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/bootstrap.php';
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_function_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
|
||||
$data = $cache->call('function_to_bench', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_to_bench', 23, 66);
|
||||
echo($data);
|
||||
$cache->call('function_to_bench', 23, 66);
|
||||
|
||||
$object = new bench();
|
||||
$object->test = 666;
|
||||
$data = $cache->call('object->method_to_bench', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('object->method_to_bench', 23, 66);
|
||||
echo($data);
|
||||
$cache->call('object->method_to_bench', 23, 66);
|
||||
|
||||
$data = $cache->call('bench::static_method_to_bench', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('bench::static_method_to_bench', 23, 66);
|
||||
echo($data);
|
||||
$cache->call('bench::static_method_to_bench', 23, 66);
|
||||
|
||||
$object = new test($options);
|
||||
|
||||
$cache->clean();
|
||||
|
||||
function function_to_bench($arg1, $arg2)
|
||||
{
|
||||
echo "This is the output of the function function_to_bench($arg1, $arg2) !\n";
|
||||
return "This is the result of the function function_to_bench($arg1, $arg2) !\n";
|
||||
}
|
||||
|
||||
class bench
|
||||
{
|
||||
var $test;
|
||||
|
||||
function method_to_bench($arg1, $arg2)
|
||||
{
|
||||
echo "\$obj->test = $this->test and this is the output of the method \$obj->method_to_bench($arg1, $arg2) !\n";
|
||||
return "\$obj->test = $this->test and this is the result of the method \$obj->method_to_bench($arg1, $arg2) !\n";
|
||||
}
|
||||
|
||||
static function static_method_to_bench($arg1, $arg2) {
|
||||
echo "This is the output of the function static_method_to_bench($arg1, $arg2) !\n";
|
||||
return "This is the result of the function static_method_to_bench($arg1, $arg2) !\n";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class test
|
||||
{
|
||||
function __construct($options) {
|
||||
$this->foo = 'bar';
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
echo($cache->call(array($this, 'method_to_bench'), 'foo', 'bar'));
|
||||
}
|
||||
|
||||
function method_to_bench($arg1, $arg2)
|
||||
{
|
||||
echo "output : *** $arg1 *** $arg2 *** " . $this->foo . " ***\n";
|
||||
return "result : *** $arg1 *** $arg2 *** " . $this->foo . " ***\n";
|
||||
}
|
||||
}
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
This is the output of the function function_to_bench(23, 66) !
|
||||
This is the result of the function function_to_bench(23, 66) !
|
||||
This is the output of the function function_to_bench(23, 66) !
|
||||
This is the result of the function function_to_bench(23, 66) !
|
||||
This is the output of the function function_to_bench(23, 66) !
|
||||
$obj->test = 666 and this is the output of the method $obj->method_to_bench(23, 66) !
|
||||
$obj->test = 666 and this is the result of the method $obj->method_to_bench(23, 66) !
|
||||
$obj->test = 666 and this is the output of the method $obj->method_to_bench(23, 66) !
|
||||
$obj->test = 666 and this is the result of the method $obj->method_to_bench(23, 66) !
|
||||
$obj->test = 666 and this is the output of the method $obj->method_to_bench(23, 66) !
|
||||
This is the output of the function static_method_to_bench(23, 66) !
|
||||
This is the result of the function static_method_to_bench(23, 66) !
|
||||
This is the output of the function static_method_to_bench(23, 66) !
|
||||
This is the result of the function static_method_to_bench(23, 66) !
|
||||
This is the output of the function static_method_to_bench(23, 66) !
|
||||
output : *** foo *** bar *** bar ***
|
||||
result : *** foo *** bar *** bar ***
|
||||
130
vendor/pear/cache_lite/tests/Cache_Lite_Function_dontcache.phpt
vendored
Normal file
130
vendor/pear/cache_lite/tests/Cache_Lite_Function_dontcache.phpt
vendored
Normal file
@@ -0,0 +1,130 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite_Function (dont cache)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_function_base.inc';
|
||||
|
||||
// Classical
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'debugCacheLiteFunction' => true
|
||||
);
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
$data = $cache->call('function_test', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test', 23, 66);
|
||||
echo($data);
|
||||
$cache->clean();
|
||||
|
||||
// Don't Cache if output contains NOCACHE
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'debugCacheLiteFunction' => true,
|
||||
'dontCacheWhenTheOutputContainsNOCACHE' => true
|
||||
);
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
$data = $cache->call('function_test2', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test2', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test2', 0, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test2', 0, 66);
|
||||
echo($data);
|
||||
$cache->clean();
|
||||
|
||||
// Don't cache if result if false
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'debugCacheLiteFunction' => true,
|
||||
'dontCacheWhenTheResultIsFalse' => true
|
||||
);
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
$data = $cache->call('function_test', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test', 0, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test', 0, 66);
|
||||
echo($data);
|
||||
$cache->clean();
|
||||
|
||||
// Don't cache if result if null
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'debugCacheLiteFunction' => true,
|
||||
'dontCacheWhenTheResultIsNull' => true
|
||||
);
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
$data = $cache->call('function_test', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test', 23, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test', 1, 66);
|
||||
echo($data);
|
||||
$data = $cache->call('function_test', 1, 66);
|
||||
echo($data);
|
||||
$cache->clean();
|
||||
|
||||
function function_test($arg1, $arg2)
|
||||
{
|
||||
echo "This is the output of the function function_test($arg1, $arg2) !\n";
|
||||
if ($arg1==0) {
|
||||
return false;
|
||||
}
|
||||
if ($arg1==1) {
|
||||
return null;
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
function function_test2($arg1, $arg2)
|
||||
{
|
||||
if ($arg1==0) {
|
||||
echo "NOCACHE";
|
||||
}
|
||||
return "This is the result of the function function_test2($arg1, $arg2) !\n";
|
||||
}
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
Cache missed !
|
||||
This is the output of the function function_test(23, 66) !
|
||||
Cache hit !
|
||||
This is the output of the function function_test(23, 66) !
|
||||
Cache missed !
|
||||
This is the result of the function function_test2(23, 66) !
|
||||
Cache hit !
|
||||
This is the result of the function function_test2(23, 66) !
|
||||
Cache missed !
|
||||
This is the result of the function function_test2(0, 66) !
|
||||
Cache missed !
|
||||
This is the result of the function function_test2(0, 66) !
|
||||
Cache missed !
|
||||
This is the output of the function function_test(23, 66) !
|
||||
Cache hit !
|
||||
This is the output of the function function_test(23, 66) !
|
||||
Cache missed !
|
||||
This is the output of the function function_test(0, 66) !
|
||||
Cache missed !
|
||||
This is the output of the function function_test(0, 66) !
|
||||
Cache missed !
|
||||
This is the output of the function function_test(23, 66) !
|
||||
Cache hit !
|
||||
This is the output of the function function_test(23, 66) !
|
||||
Cache missed !
|
||||
This is the output of the function function_test(1, 66) !
|
||||
Cache missed !
|
||||
This is the output of the function function_test(1, 66) !
|
||||
50
vendor/pear/cache_lite/tests/Cache_Lite_Function_drop.phpt
vendored
Normal file
50
vendor/pear/cache_lite/tests/Cache_Lite_Function_drop.phpt
vendored
Normal file
@@ -0,0 +1,50 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite_Function (drop() method)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_function_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60
|
||||
);
|
||||
$foo = 10;
|
||||
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
|
||||
$data = $cache->call('function_to_bench', 23, 66);
|
||||
echo($data."\n");
|
||||
$data = $cache->call('function_to_bench', 23, 66);
|
||||
echo($data."\n");
|
||||
$cache->drop('function_to_bench', 23, 66);
|
||||
$data = $cache->call('function_to_bench', 23, 66);
|
||||
echo($data."\n");
|
||||
$data = $cache->call('function_to_bench', 23, 66);
|
||||
echo($data."\n");
|
||||
$cache->clean();
|
||||
|
||||
function function_to_bench($arg1, $arg2)
|
||||
{
|
||||
global $foo;
|
||||
$foo = $foo + 1;
|
||||
echo "hello !\n";
|
||||
return($foo + $arg1 + $arg2);
|
||||
}
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
hello !
|
||||
100
|
||||
hello !
|
||||
100
|
||||
hello !
|
||||
101
|
||||
hello !
|
||||
101
|
||||
53
vendor/pear/cache_lite/tests/Cache_Lite_Output_classical.phpt
vendored
Normal file
53
vendor/pear/cache_lite/tests/Cache_Lite_Output_classical.phpt
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite_Output (classical)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_output_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60
|
||||
);
|
||||
|
||||
$Cache_Lite_Output = new Cache_Lite_Output($options);
|
||||
multipleCallCache2();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789Cache Missed !
|
||||
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789Cache Hit !
|
||||
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789Cache Hit !
|
||||
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789Cache Missed !
|
||||
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789Cache Missed !
|
||||
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
57
vendor/pear/cache_lite/tests/Cache_Lite_automaticCleaning.phpt
vendored
Normal file
57
vendor/pear/cache_lite/tests/Cache_Lite_automaticCleaning.phpt
vendored
Normal file
@@ -0,0 +1,57 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (automaticCleaning)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/bootstrap.php';
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 2,
|
||||
'automaticCleaningFactor' => 1
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
callCache('31415926');
|
||||
echo("\n");
|
||||
callCache('31415926');
|
||||
echo("\n");
|
||||
callCache('31415926bis');
|
||||
echo("\n");
|
||||
callCache('31415926bis');
|
||||
echo("\n");
|
||||
sleep(4);
|
||||
callCache('31415926'); // '31415926bis' will be cleaned
|
||||
echo "\n";
|
||||
$dh = opendir(tmpDir());
|
||||
while ($file = readdir($dh)) {
|
||||
if (($file != '.') && ($file != '..')) {
|
||||
if (substr($file, 0, 6)=='cache_') {
|
||||
echo "$file\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$Cache_Lite->remove('31415926');
|
||||
$Cache_Lite->remove('31415926bis');
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
cache_c21f969b5f03d33d43e04f8f136e7682_e9982ec5ca981bd365603623cf4b2277
|
||||
53
vendor/pear/cache_lite/tests/Cache_Lite_classical.phpt
vendored
Normal file
53
vendor/pear/cache_lite/tests/Cache_Lite_classical.phpt
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (classical)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
64
vendor/pear/cache_lite/tests/Cache_Lite_error.phpt
vendored
Normal file
64
vendor/pear/cache_lite/tests/Cache_Lite_error.phpt
vendored
Normal file
@@ -0,0 +1,64 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (error)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/bootstrap.php';
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '31451992gjhgjh'. '/', # I hope there will be no directory with that silly name
|
||||
'lifeTime' => 60
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Error when saving cache !
|
||||
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Error when saving cache !
|
||||
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Error when saving cache !
|
||||
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Error when saving cache !
|
||||
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Error when saving cache !
|
||||
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
66
vendor/pear/cache_lite/tests/Cache_Lite_error2.phpt
vendored
Normal file
66
vendor/pear/cache_lite/tests/Cache_Lite_error2.phpt
vendored
Normal file
@@ -0,0 +1,66 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (error2)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/bootstrap.php';
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$tmpdir = tmpDir() . '31451992gjhgjh'. '/'; # I hope there will be no directory with that silly name
|
||||
$options = array(
|
||||
'cacheDir' => $tmpdir,
|
||||
'lifeTime' => 60,
|
||||
'errorHandlingAPIBreak' => true
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
PEAR_ERROR : Cache_Lite : Unable to write cache file : <cachedir>/31451992gjhgjh/cache_c21f969b5f03d33d43e04f8f136e7682_e9982ec5ca981bd365603623cf4b2277 (#-1)
|
||||
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
PEAR_ERROR : Cache_Lite : Unable to write cache file : <cachedir>/31451992gjhgjh/cache_c21f969b5f03d33d43e04f8f136e7682_e9982ec5ca981bd365603623cf4b2277 (#-1)
|
||||
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
PEAR_ERROR : Cache_Lite : Unable to write cache file : <cachedir>/31451992gjhgjh/cache_c21f969b5f03d33d43e04f8f136e7682_e9982ec5ca981bd365603623cf4b2277 (#-1)
|
||||
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
PEAR_ERROR : Cache_Lite : Unable to write cache file : <cachedir>/31451992gjhgjh/cache_c21f969b5f03d33d43e04f8f136e7682_e9982ec5ca981bd365603623cf4b2277 (#-1)
|
||||
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
PEAR_ERROR : Cache_Lite : Unable to write cache file : <cachedir>/31451992gjhgjh/cache_c21f969b5f03d33d43e04f8f136e7682_07eeaa82211be6c3335603523dbea0a3 (#-1)
|
||||
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
53
vendor/pear/cache_lite/tests/Cache_Lite_eternal.phpt
vendored
Normal file
53
vendor/pear/cache_lite/tests/Cache_Lite_eternal.phpt
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (eternal)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => null
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
57
vendor/pear/cache_lite/tests/Cache_Lite_fatest.phpt
vendored
Normal file
57
vendor/pear/cache_lite/tests/Cache_Lite_fatest.phpt
vendored
Normal file
@@ -0,0 +1,57 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (fatest, no control, no lock)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'fileLocking' => false,
|
||||
'writeControl' => false,
|
||||
'readControl' => false,
|
||||
'fileNameProtection' => false
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
98
vendor/pear/cache_lite/tests/Cache_Lite_hashed.phpt
vendored
Normal file
98
vendor/pear/cache_lite/tests/Cache_Lite_hashed.phpt
vendored
Normal file
@@ -0,0 +1,98 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (hashed level 2)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'hashedDirectoryLevel' => 2
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
// Hack to clean cache directory structure
|
||||
/**
|
||||
* rm() -- Vigorously erase files and directories.
|
||||
*
|
||||
* @param $fileglob mixed If string, must be a file name (foo.txt), glob pattern (*.txt), or directory name.
|
||||
* If array, must be an array of file names, glob patterns, or directories.
|
||||
*/
|
||||
function rm($fileglob)
|
||||
{
|
||||
if (is_string($fileglob)) {
|
||||
if (is_file($fileglob)) {
|
||||
return unlink($fileglob);
|
||||
} else if (is_dir($fileglob)) {
|
||||
$ok = rm("$fileglob/*");
|
||||
if (! $ok) {
|
||||
return false;
|
||||
}
|
||||
return rmdir($fileglob);
|
||||
} else {
|
||||
$matching = glob($fileglob);
|
||||
if ($matching === false) {
|
||||
trigger_error(sprintf('No files match supplied glob %s', $fileglob), E_USER_WARNING);
|
||||
return false;
|
||||
}
|
||||
$rcs = array_map('rm', $matching);
|
||||
if (in_array(false, $rcs)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else if (is_array($fileglob)) {
|
||||
$rcs = array_map('rm', $fileglob);
|
||||
if (in_array(false, $rcs)) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
trigger_error('Param #1 must be filename or glob pattern, or array of filenames or glob patterns', E_USER_ERROR);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
rm(tmpDir() . '/cache_*');
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
42
vendor/pear/cache_lite/tests/Cache_Lite_lifetime.phpt
vendored
Normal file
42
vendor/pear/cache_lite/tests/Cache_Lite_lifetime.phpt
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (lifetime)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 2
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
callCache('31415926');
|
||||
echo("\n");
|
||||
callCache('31415926');
|
||||
echo("\n");
|
||||
sleep(4);
|
||||
callCache('31415926');
|
||||
echo("\n");
|
||||
sleep(4);
|
||||
$Cache_Lite->extendLife();
|
||||
callCache('31415926');
|
||||
echo("\n");
|
||||
$Cache_Lite->remove('31415926');
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
54
vendor/pear/cache_lite/tests/Cache_Lite_memorycache.phpt
vendored
Normal file
54
vendor/pear/cache_lite/tests/Cache_Lite_memorycache.phpt
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (memory cache on)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'memoryCaching' => false
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
54
vendor/pear/cache_lite/tests/Cache_Lite_serialization.phpt
vendored
Normal file
54
vendor/pear/cache_lite/tests/Cache_Lite_serialization.phpt
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (automatic serialization on)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'automaticSerialization' => true
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache('array');
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
a:4:{i:0;a:2:{i:0;s:3:"foo";i:1;s:3:"bar";}i:1;i:1;i:2;s:3:"foo";i:3;s:3:"bar";}
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
a:4:{i:0;a:2:{i:0;s:3:"foo";i:1;s:3:"bar";}i:1;i:1;i:2;s:3:"foo";i:3;s:3:"bar";}
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
a:4:{i:0;a:2:{i:0;s:3:"foo";i:1;s:3:"bar";}i:1;i:1;i:2;s:3:"foo";i:3;s:3:"bar";}
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
a:4:{i:0;a:2:{i:0;s:3:"foo";i:1;s:3:"bar";}i:1;i:1;i:2;s:3:"foo";i:3;s:3:"bar";}
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
a:4:{i:0;a:2:{i:0;s:3:"foo";i:1;s:3:"bar";}i:1;i:1;i:2;s:3:"foo";i:3;s:3:"bar";}
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
30
vendor/pear/cache_lite/tests/ErrorDieTest.php
vendored
Normal file
30
vendor/pear/cache_lite/tests/ErrorDieTest.php
vendored
Normal file
@@ -0,0 +1,30 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Test for CACHE_LITE_ERROR_DIE
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @category Caching
|
||||
* @version $Id$
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
|
||||
class ErrorDieTest extends PHPUnit_Framework_TestCase
|
||||
{
|
||||
public function testErrorDie()
|
||||
{
|
||||
exec('/usr/bin/env php ' . __DIR__ . DIRECTORY_SEPARATOR . 'errordie.php', $out);
|
||||
$message = join(PHP_EOL, $out);
|
||||
$message = str_replace(tmpDir(), '<cachedir>/', $message); // Remove system specific cache dir
|
||||
$expected = join(PHP_EOL, array(
|
||||
'==> First call (cache should be missed)',
|
||||
'Cache Missed !',
|
||||
'0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789Cache_Lite : Unable to write cache file : <cachedir>/31451992gjhgjh/cache_c21f969b5f03d33d43e04f8f136e7682_e9982ec5ca981bd365603623cf4b2277',
|
||||
));
|
||||
|
||||
$this->assertEquals($message, $expected);
|
||||
|
||||
}
|
||||
}
|
||||
63
vendor/pear/cache_lite/tests/NestedOutputTest.php
vendored
Normal file
63
vendor/pear/cache_lite/tests/NestedOutputTest.php
vendored
Normal file
@@ -0,0 +1,63 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Test for Cache_Lite_NestedOutput
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @category Caching
|
||||
* @version $Id$
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite/NestedOutput.php';
|
||||
|
||||
class NestedOutputTest extends PHPUnit_Framework_TestCase
|
||||
{
|
||||
/**
|
||||
* "Test" used for documenting the nested output buffering feature of php
|
||||
*/
|
||||
public function testPhpObNesting()
|
||||
{
|
||||
$outsideText = "This is the outside";
|
||||
$insideText = "This is the inside";
|
||||
ob_start();
|
||||
echo $outsideText;
|
||||
ob_start();
|
||||
echo $insideText;
|
||||
$innerContents = ob_get_contents();
|
||||
ob_end_clean();
|
||||
$outerContents = ob_get_contents();
|
||||
ob_end_clean();
|
||||
|
||||
$this->assertEquals( $insideText, $innerContents );
|
||||
$this->assertEquals( $outsideText, $outerContents );
|
||||
}
|
||||
|
||||
/**
|
||||
* Test for Cache_Lite_NestedOutput
|
||||
*/
|
||||
public function testCacheLiteOutputNesting()
|
||||
{
|
||||
$outsideText = "This is the outside";
|
||||
$insideText = "This is the inside";
|
||||
|
||||
$options = array(
|
||||
'caching' => true,
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
$cache = new Cache_Lite_NestedOutput($options);
|
||||
$this->assertFalse($cache->start('foo', 'a'));
|
||||
echo $outsideText;
|
||||
$this->assertFalse($cache->start('bar', 'b'));
|
||||
echo $insideText;
|
||||
$inside = $cache->end();
|
||||
$outside = $cache->end();
|
||||
$this->assertEquals($outsideText, $outside, 'Validate outside');
|
||||
$this->assertEquals($insideText, $inside, 'Validate inside');
|
||||
|
||||
$cache = new Cache_Lite_NestedOutput($options);
|
||||
$this->assertEquals($outsideText, $cache->start('foo', 'a'), 'Validate outside');
|
||||
$this->assertEquals($insideText, $cache->start('bar', 'b'), 'Validate inside');
|
||||
}
|
||||
}
|
||||
27
vendor/pear/cache_lite/tests/bench.php
vendored
Normal file
27
vendor/pear/cache_lite/tests/bench.php
vendored
Normal file
@@ -0,0 +1,27 @@
|
||||
<?php
|
||||
|
||||
// Bench script of Cache_Lite
|
||||
// $Id$
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite.php';
|
||||
|
||||
$options = array(
|
||||
'caching' => true,
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
|
||||
if ($data = $Cache_Lite->get('123')) {
|
||||
echo($data);
|
||||
} else {
|
||||
$data = '';
|
||||
for($i=0;$i<1000;$i++) {
|
||||
$data .= '0123456789';
|
||||
}
|
||||
echo($data);
|
||||
$Cache_Lite->save($data);
|
||||
}
|
||||
|
||||
?>
|
||||
24
vendor/pear/cache_lite/tests/bench2.php
vendored
Normal file
24
vendor/pear/cache_lite/tests/bench2.php
vendored
Normal file
@@ -0,0 +1,24 @@
|
||||
<?php
|
||||
|
||||
// Bench script of Cache_Lite_Output
|
||||
// $Id$
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite/Output.php';
|
||||
|
||||
$options = array(
|
||||
'caching' => true,
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Output($options);
|
||||
|
||||
if (!($cache->start('123'))) {
|
||||
// Cache missed...
|
||||
for($i=0;$i<1000;$i++) { // Making of the page...
|
||||
echo('0123456789');
|
||||
}
|
||||
$cache->end();
|
||||
}
|
||||
|
||||
?>
|
||||
60
vendor/pear/cache_lite/tests/bench3.php
vendored
Normal file
60
vendor/pear/cache_lite/tests/bench3.php
vendored
Normal file
@@ -0,0 +1,60 @@
|
||||
<?php
|
||||
|
||||
// Bench script of Cache_Lite_Function
|
||||
// $Id$
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite/Function.php';
|
||||
|
||||
$options = array(
|
||||
'caching' => true,
|
||||
'cacheDir' => '/tmp/',
|
||||
'lifeTime' => 10
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite_Function($options);
|
||||
|
||||
$data = $cache->call('function_to_bench', 23, 66);
|
||||
echo($data);
|
||||
|
||||
$object = new bench();
|
||||
$object->test = 666;
|
||||
$data = $cache->call('object->method_to_bench', 23, 66);
|
||||
echo($data);
|
||||
|
||||
$data = $cache->call('bench::static_method_to_bench', 23, 66);
|
||||
echo($data);
|
||||
|
||||
function function_to_bench($arg1, $arg2)
|
||||
{
|
||||
for($i=0;$i<10000;$i++) {
|
||||
$tmp = md5(md5(md5('Loosing time...')));
|
||||
}
|
||||
echo "This is the output of the function function_to_bench($arg1, $arg2) !<br>";
|
||||
return "This is the result of the function function_to_bench($arg1, $arg2) !<br>";
|
||||
}
|
||||
|
||||
class bench
|
||||
{
|
||||
var $test;
|
||||
|
||||
function method_to_bench($arg1, $arg2)
|
||||
{
|
||||
for($i=0;$i<10000;$i++) {
|
||||
$tmp = md5(md5(md5('Loosing time...')));
|
||||
}
|
||||
echo "\$obj->test = $this->test and this is the output of the method \$obj->method_to_bench($arg1, $arg2) !<br>";
|
||||
return "\$obj->test = $this->test and this is the result of the method \$obj->method_to_bench($arg1, $arg2) !<br>";
|
||||
}
|
||||
|
||||
function static_method_to_bench($arg1, $arg2)
|
||||
{
|
||||
for($i=0;$i<10000;$i++) {
|
||||
$tmp = md5(md5(md5('Loosing time...')));
|
||||
}
|
||||
echo "This is the output of the function static_method_to_bench($arg1, $arg2) !<br>";
|
||||
return "This is the result of the function static_method_to_bench($arg1, $arg2) !<br>";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
7
vendor/pear/cache_lite/tests/bootstrap.php
vendored
Normal file
7
vendor/pear/cache_lite/tests/bootstrap.php
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
<?php
|
||||
|
||||
if (version_compare(PHP_VERSION, '5.4', '>=')) {
|
||||
error_reporting(E_ALL ^ E_STRICT);
|
||||
} else if (version_compare(PHP_VERSION, '5.3', '>=')) {
|
||||
error_reporting(E_ALL & ~E_STRICT);
|
||||
}
|
||||
3
vendor/pear/cache_lite/tests/cache_lite_base.inc
vendored
Normal file
3
vendor/pear/cache_lite/tests/cache_lite_base.inc
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
<?php
|
||||
require_once('Cache/Lite.php');
|
||||
?>
|
||||
3
vendor/pear/cache_lite/tests/cache_lite_file_base.inc
vendored
Normal file
3
vendor/pear/cache_lite/tests/cache_lite_file_base.inc
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
<?php
|
||||
require_once('Cache/Lite/File.php');
|
||||
?>
|
||||
3
vendor/pear/cache_lite/tests/cache_lite_function_base.inc
vendored
Normal file
3
vendor/pear/cache_lite/tests/cache_lite_function_base.inc
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
<?php
|
||||
require_once('Cache/Lite/Function.php');
|
||||
?>
|
||||
3
vendor/pear/cache_lite/tests/cache_lite_output_base.inc
vendored
Normal file
3
vendor/pear/cache_lite/tests/cache_lite_output_base.inc
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
<?php
|
||||
require_once 'Cache/Lite/Output.php';
|
||||
?>
|
||||
151
vendor/pear/cache_lite/tests/callcache.inc
vendored
Normal file
151
vendor/pear/cache_lite/tests/callcache.inc
vendored
Normal file
@@ -0,0 +1,151 @@
|
||||
<?php
|
||||
|
||||
function callCache($id, $type = 'string') {
|
||||
global $Cache_Lite;
|
||||
if ($data = $Cache_Lite->get($id)) {
|
||||
echo("Cache Hit !\n");
|
||||
if ($type=='string') {
|
||||
echo($data);
|
||||
}
|
||||
if ($type=='array') {
|
||||
echo(serialize($data));
|
||||
}
|
||||
} else {
|
||||
echo("Cache Missed !\n");
|
||||
if ($type=='string') {
|
||||
$data = '';
|
||||
for($i=0;$i<10;$i++) {
|
||||
$data .= '0123456789';
|
||||
}
|
||||
echo($data);
|
||||
}
|
||||
if ($type=='array') {
|
||||
$data = array(array('foo', 'bar'), 1, 'foo', 'bar');
|
||||
echo(serialize($data));
|
||||
}
|
||||
$res = $Cache_Lite->save($data);
|
||||
if (is_object($res)) {
|
||||
$message = $res->getMessage();
|
||||
$message = str_replace(tmpDir(), '<cachedir>/', $message); // Remove system specific cache dir
|
||||
echo "\nPEAR_ERROR : " . $message . " (#" . $res->getCode() . ")\n";
|
||||
} else {
|
||||
if (!($res)) {
|
||||
echo "\nError when saving cache !\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function multipleCallCache($type = 'string') {
|
||||
global $Cache_Lite;
|
||||
|
||||
echo "==> First call (cache should be missed)\n";
|
||||
callCache('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> Second call (cache should be hit)\n";
|
||||
callCache('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> Third call (cache should be hit)\n";
|
||||
callCache('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> We remove cache\n";
|
||||
$Cache_Lite->remove('31415926');
|
||||
echo "Done !\n\n";
|
||||
|
||||
echo "==> Fourth call (cache should be missed)\n";
|
||||
callCache('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> #5 Call with another id (cache should be missed)\n";
|
||||
callCache('3141592653', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> We remove cache\n";
|
||||
$Cache_Lite->remove('31415926');
|
||||
$Cache_Lite->remove('3141592653');
|
||||
echo "Done !\n";
|
||||
}
|
||||
|
||||
function callCache2($id, $type = 'string') {
|
||||
global $Cache_Lite_Output;
|
||||
if (!($Cache_Lite_Output->start($id))) {
|
||||
if ($type=='string') {
|
||||
$data = '';
|
||||
for($i=0;$i<10;$i++) {
|
||||
$data .= '0123456789';
|
||||
}
|
||||
echo($data);
|
||||
}
|
||||
if ($type=='array') {
|
||||
$data = array(array('foo', 'bar'), 1, 'foo', 'bar');
|
||||
echo(serialize($data));
|
||||
}
|
||||
$Cache_Lite_Output->end();
|
||||
echo("Cache Missed !\n");
|
||||
} else {
|
||||
echo("Cache Hit !\n");
|
||||
}
|
||||
}
|
||||
|
||||
function multipleCallCache2($type = 'string') {
|
||||
global $Cache_Lite_Output;
|
||||
|
||||
echo "==> First call (cache should be missed)\n";
|
||||
callCache2('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> Second call (cache should be hit)\n";
|
||||
callCache2('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> Third call (cache should be hit)\n";
|
||||
callCache2('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> We remove cache\n";
|
||||
$Cache_Lite_Output->remove('31415926');
|
||||
echo "Done !\n\n";
|
||||
|
||||
echo "==> Fourth call (cache should be missed)\n";
|
||||
callCache2('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> #5 Call with another id (cache should be missed)\n";
|
||||
callCache2('3141592653', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> We remove cache\n";
|
||||
$Cache_Lite_Output->remove('31415926');
|
||||
$Cache_Lite_Output->remove('3141592653');
|
||||
echo "Done !\n";
|
||||
}
|
||||
|
||||
function multipleCallCache3_1($type = 'string') {
|
||||
global $Cache_Lite;
|
||||
|
||||
echo "==> #6 call (cache should be missed)\n";
|
||||
callCache('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> #7 call (cache should be hit)\n";
|
||||
callCache('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
}
|
||||
|
||||
function multipleCallCache3_2($type = 'string') {
|
||||
global $Cache_Lite;
|
||||
|
||||
echo "==> #8 call (cache should be missed)\n";
|
||||
callCache('31415926', $type);
|
||||
echo "\nDone !\n\n";
|
||||
|
||||
echo "==> We remove cache\n";
|
||||
$Cache_Lite->remove('31415926');
|
||||
echo "Done !\n";
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
25
vendor/pear/cache_lite/tests/errordie.php
vendored
Normal file
25
vendor/pear/cache_lite/tests/errordie.php
vendored
Normal file
@@ -0,0 +1,25 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Executed by ErrorDieTest
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @category Caching
|
||||
* @version $Id$
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
error_reporting(0);
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '31451992gjhgjh'. '/', # I hope there will be no directory with that silly name
|
||||
'lifeTime' => 60,
|
||||
'pearErrorMode' => CACHE_LITE_ERROR_DIE
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
33
vendor/pear/cache_lite/tests/pearbug13693.phpt
vendored
Normal file
33
vendor/pear/cache_lite/tests/pearbug13693.phpt
vendored
Normal file
@@ -0,0 +1,33 @@
|
||||
--TEST--
|
||||
pearbug13693
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
require_once __DIR__ . '/bootstrap.php';
|
||||
require_once __DIR__ . '/../Cache/Lite.php';
|
||||
|
||||
// Create temp dir
|
||||
$dir = dirname( __FILE__ ) . '/' . uniqid();
|
||||
mkdir($dir);
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => $dir,
|
||||
'lifeTime' => 60,
|
||||
);
|
||||
$id = '#13693';
|
||||
$cache = new Cache_Lite($options);
|
||||
$cache->save('stuff', $id);
|
||||
// Must be true
|
||||
echo $cache->remove($id) === true ? "OK\n" : "ERROR\n";
|
||||
// Will return a PEAR Error
|
||||
echo $cache->remove($id) instanceof PEAR_Error ? "OK\n" : "ERROR\n";
|
||||
// Will return true
|
||||
echo $cache->remove($id, 'default', true) === true ? "OK\n" : "ERROR\n";
|
||||
|
||||
// Remove temp dir
|
||||
rmdir($dir);
|
||||
--EXPECT--
|
||||
OK
|
||||
OK
|
||||
OK
|
||||
17
vendor/pear/cache_lite/tests/pearbug18192.php
vendored
Normal file
17
vendor/pear/cache_lite/tests/pearbug18192.php
vendored
Normal file
@@ -0,0 +1,17 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Process for test pearbug18192
|
||||
*
|
||||
* @see https://pear.php.net/bugs/bug.php?id=18192
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite.php';
|
||||
$c = new Cache_Lite(array('cacheDir' => '.', 'lifeTime' => 60));
|
||||
$id = '#18192';
|
||||
for ($i = 0; $i < 100000; $i++) {
|
||||
$str = uniqid('some-string', true);
|
||||
if (!$c->save($str, $id)) fputs(STDERR, "Error saving.\n");
|
||||
if ($c->get($id) !== $str) fputs(STDERR, "Wrong data.\n");
|
||||
}
|
||||
25
vendor/pear/cache_lite/tests/pearbug18328.phpt
vendored
Normal file
25
vendor/pear/cache_lite/tests/pearbug18328.phpt
vendored
Normal file
@@ -0,0 +1,25 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (PEAR bug #18328)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Process for test pearbug18328
|
||||
*
|
||||
* @see https://pear.php.net/bugs/bug.php?id=18328
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite.php';
|
||||
$c = new Cache_Lite(array('cacheDir' => '.', 'lifeTime' => 60,));
|
||||
var_dump($c->_cacheDir === '.');
|
||||
$c = new Cache_Lite(array('lifeTime' => 60));
|
||||
var_dump($c->_cacheDir === (function_exists('sys_get_temp_dir') ? sys_get_temp_dir() . DIRECTORY_SEPARATOR : '/tmp/'));
|
||||
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
bool(true)
|
||||
bool(true)
|
||||
133
vendor/pear/cache_lite/tests/pearbug19422.phpt
vendored
Normal file
133
vendor/pear/cache_lite/tests/pearbug19422.phpt
vendored
Normal file
@@ -0,0 +1,133 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (PEAR bug #19422)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Test for Pear Bug #19422
|
||||
*
|
||||
* @see https://pear.php.net/bugs/bug.php?id=19422
|
||||
* @see https://bugs.php.net/bug.php?id=30936
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @category Caching
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite.php';
|
||||
|
||||
define('FsStreamWrapper_CACHE_DIR', sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'cachelite-streamwrapper' . DIRECTORY_SEPARATOR);
|
||||
|
||||
class FsStreamWrapper
|
||||
{
|
||||
const SCHEME = 'public';
|
||||
private $fp;
|
||||
|
||||
public function __construct()
|
||||
{
|
||||
if (!is_dir(FsStreamWrapper_CACHE_DIR)) mkdir(FsStreamWrapper_CACHE_DIR);
|
||||
}
|
||||
|
||||
public function url_stat($path, $flags)
|
||||
{
|
||||
$localpath = $this->scheme2file($path);
|
||||
if (!is_file($localpath)) return 0;
|
||||
return stat($localpath);
|
||||
}
|
||||
|
||||
private function scheme2file($path)
|
||||
{
|
||||
return str_replace(self::SCHEME . '://', FsStreamWrapper_CACHE_DIR, $path);
|
||||
}
|
||||
|
||||
public function stream_open($path, $mode, $options, &$opath)
|
||||
{
|
||||
$this->fp = fopen($this->scheme2file($path), $mode);
|
||||
return true;
|
||||
}
|
||||
|
||||
public function stream_write($data)
|
||||
{
|
||||
return fwrite($this->fp, $data);
|
||||
}
|
||||
|
||||
public function stream_close()
|
||||
{
|
||||
return fclose($this->fp);
|
||||
}
|
||||
|
||||
public function stream_lock($operation)
|
||||
{
|
||||
return flock($this->fp, $operation);
|
||||
}
|
||||
|
||||
public function unlink($path)
|
||||
{
|
||||
return unlink($this->scheme2file($path));
|
||||
}
|
||||
|
||||
public function stream_read($count)
|
||||
{
|
||||
return fread($this->fp, $count);
|
||||
}
|
||||
|
||||
public function stream_eof()
|
||||
{
|
||||
return feof($this->fp);
|
||||
}
|
||||
|
||||
public function stream_seek($offset, $whence)
|
||||
{
|
||||
return !fseek($this->fp, $offset, $whence);
|
||||
}
|
||||
|
||||
public function stream_flush()
|
||||
{
|
||||
return fflush($this->fp);
|
||||
}
|
||||
|
||||
public function stream_tell()
|
||||
{
|
||||
return ftell($this->fp);
|
||||
}
|
||||
|
||||
public function rename($from_uri, $to_uri)
|
||||
{
|
||||
return rename($this->scheme2file($from_uri), $this->scheme2file($to_uri));
|
||||
}
|
||||
}
|
||||
|
||||
$xml = array();
|
||||
$cacheOpt = array();
|
||||
$cacheOpt['cacheDir'] = 'public://';
|
||||
$cacheOpt['cache_time'] = 3600;
|
||||
$Cache_Lite = new Cache_Lite($cacheOpt);
|
||||
$Cache_Lite->setToDebug();
|
||||
|
||||
stream_wrapper_register(FsStreamWrapper::SCHEME, 'FsStreamWrapper');
|
||||
|
||||
$fp = fopen('/dev/urandom', 'r');
|
||||
$data = fread($fp, 32 * 1024);
|
||||
fclose($fp);
|
||||
$Cache_Lite->save($data, 'largechache');
|
||||
$verify = $Cache_Lite->get('largechache');
|
||||
|
||||
var_dump(strlen($data) === strlen($verify));
|
||||
var_dump($data === $verify);
|
||||
|
||||
?>
|
||||
--CLEAN--
|
||||
<?php
|
||||
define('FsStreamWrapper_CACHE_DIR', sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'cachelite-streamwrapper' . DIRECTORY_SEPARATOR);
|
||||
foreach(glob(FsStreamWrapper_CACHE_DIR . 'cache*') as $file) {
|
||||
unlink($file);
|
||||
}
|
||||
@rmdir(FsStreamWrapper_CACHE_DIR);
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
bool(true)
|
||||
bool(true)
|
||||
38
vendor/pear/cache_lite/tests/pearbug19711.phpt
vendored
Normal file
38
vendor/pear/cache_lite/tests/pearbug19711.phpt
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
--TEST--
|
||||
Cache_Lite::Cache_Lite (PEAR bug #19711)
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Test for Pear Bug #19711
|
||||
*
|
||||
* @see https://pear.php.net/bugs/bug.php?id=19711
|
||||
*
|
||||
* @package Cache_Lite
|
||||
* @category Caching
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
require_once __DIR__ . '/../Cache/Lite.php';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'automaticSerialization' => true
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
$data = array('apples', 'oranges');
|
||||
$Cache_Lite->save($data, 'array_cached');
|
||||
$fetched_data = $Cache_Lite->get('array_cached');
|
||||
|
||||
var_dump($data === $fetched_data);
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
bool(true)
|
||||
54
vendor/pear/cache_lite/tests/pearbug513.phpt
vendored
Normal file
54
vendor/pear/cache_lite/tests/pearbug513.phpt
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
--TEST--
|
||||
pearbug513
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'automaticSerialization' => true
|
||||
);
|
||||
|
||||
$Cache_Lite = new Cache_Lite($options);
|
||||
multipleCallCache();
|
||||
|
||||
?>
|
||||
--GET--
|
||||
--POST--
|
||||
--EXPECT--
|
||||
==> First call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Second call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> Third call (cache should be hit)
|
||||
Cache Hit !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
|
||||
==> Fourth call (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> #5 Call with another id (cache should be missed)
|
||||
Cache Missed !
|
||||
0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
|
||||
Done !
|
||||
|
||||
==> We remove cache
|
||||
Done !
|
||||
41
vendor/pear/cache_lite/tests/pearbug7618.phpt
vendored
Normal file
41
vendor/pear/cache_lite/tests/pearbug7618.phpt
vendored
Normal file
@@ -0,0 +1,41 @@
|
||||
--TEST--
|
||||
pearbug7618
|
||||
--INI--
|
||||
track_errors=Off
|
||||
--FILE--
|
||||
<?php
|
||||
|
||||
require_once __DIR__ . '/callcache.inc';
|
||||
require_once __DIR__ . '/tmpdir.inc';
|
||||
require_once __DIR__ . '/cache_lite_base.inc';
|
||||
|
||||
$options = array(
|
||||
'cacheDir' => tmpDir() . '/',
|
||||
'lifeTime' => 60,
|
||||
'automaticSerialization' => true
|
||||
);
|
||||
|
||||
$cache = new Cache_Lite($options);
|
||||
$cacheid = "testid";
|
||||
$tmpar = array();
|
||||
for ($i=0; $i<2; $i++) {
|
||||
$ar[] = 'foo';
|
||||
if ($cache->save($ar,$cacheid)) {
|
||||
echo "TRUE\n";
|
||||
} else {
|
||||
echo "FALSE\n";
|
||||
}
|
||||
if ($data = $cache->get($cacheid)) {
|
||||
echo($data[0] . "\n");
|
||||
} else {
|
||||
echo "FALSE\n";
|
||||
}
|
||||
}
|
||||
$cache->remove('testid');
|
||||
|
||||
?>
|
||||
--EXPECT--
|
||||
TRUE
|
||||
foo
|
||||
TRUE
|
||||
foo
|
||||
17
vendor/pear/cache_lite/tests/readme
vendored
Normal file
17
vendor/pear/cache_lite/tests/readme
vendored
Normal file
@@ -0,0 +1,17 @@
|
||||
Cache_Lite is perfs oriented. So before commiting, please bench your patch !
|
||||
|
||||
To bench Cache_Lite, I use the tool 'ab' (distributed with apache).
|
||||
|
||||
(for example)
|
||||
/usr/sbin/ab -c 10 -n 1000 http://127.0.0.1/ [...] /Cache_Lite/tests/bench.php
|
||||
|
||||
In the output of 'ab', most important things are :
|
||||
- Failed requests: (must be 0 ! If not, don't commit !)
|
||||
- Requests per second: XXX [#/sec] (mean)
|
||||
|
||||
|
||||
For testing if the cache is ok or not, you can use the script 'test.php', it
|
||||
will write if the cache has been hit or missed...
|
||||
|
||||
|
||||
Fabien (fab@php.net)
|
||||
40
vendor/pear/cache_lite/tests/tmpdir.inc
vendored
Normal file
40
vendor/pear/cache_lite/tests/tmpdir.inc
vendored
Normal file
@@ -0,0 +1,40 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @author Markus Tacker <tacker@php.net>
|
||||
*/
|
||||
|
||||
/**
|
||||
* @const String Temp dir for cache files
|
||||
*/
|
||||
define('TEST_TMP_DIR_DEFAULT', __DIR__ . DIRECTORY_SEPARATOR . 'tmp' . DIRECTORY_SEPARATOR);
|
||||
|
||||
/**
|
||||
* Returns a directory to use for temp files.
|
||||
*
|
||||
* The dir is now hard coded to a local dir to make the tests runnable
|
||||
* under jenkins where there is no write access to the system temp dir.
|
||||
*
|
||||
* The reason for this solution is, that with phpt files a given
|
||||
* --bootstrap file is ignored.
|
||||
*
|
||||
* @author Markus Tacker <tacker@php.net>*
|
||||
* @static
|
||||
* @access public
|
||||
* @return string The system tmp directory
|
||||
*/
|
||||
function tmpDir()
|
||||
{
|
||||
if (defined('TEST_TMP_DIR')) return TEST_TMP_DIR;
|
||||
return TEST_TMP_DIR_DEFAULT;
|
||||
}
|
||||
|
||||
// Create directory if not exists
|
||||
if (!is_dir(tmpDir())) mkdir(tmpDir());
|
||||
|
||||
// Clean up afterwards
|
||||
register_shutdown_function(function()
|
||||
{
|
||||
exec('rm -rf ' . tmpDir());
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user