diff --git a/core/composer.lock b/core/composer.lock index 49c5581..e77d0e7 100644 --- a/core/composer.lock +++ b/core/composer.lock @@ -238,16 +238,16 @@ }, { "name": "doctrine/cache", - "version": "v1.3.1", + "version": "v1.4.1", "source": { "type": "git", "url": "https://github.com/doctrine/cache.git", - "reference": "cf483685798a72c93bf4206e3dd6358ea07d64e7" + "reference": "c9eadeb743ac6199f7eec423cb9426bc518b7b03" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/doctrine/cache/zipball/cf483685798a72c93bf4206e3dd6358ea07d64e7", - "reference": "cf483685798a72c93bf4206e3dd6358ea07d64e7", + "url": "https://api.github.com/repos/doctrine/cache/zipball/c9eadeb743ac6199f7eec423cb9426bc518b7b03", + "reference": "c9eadeb743ac6199f7eec423cb9426bc518b7b03", "shasum": "" }, "require": { @@ -258,12 +258,13 @@ }, "require-dev": { "phpunit/phpunit": ">=3.7", + "predis/predis": "~1.0", "satooshi/php-coveralls": "~0.6" }, "type": "library", "extra": { "branch-alias": { - "dev-master": "1.4.x-dev" + "dev-master": "1.5.x-dev" } }, "autoload": { @@ -303,7 +304,7 @@ "cache", "caching" ], - "time": "2014-09-17 14:24:04" + "time": "2015-04-15 00:11:59" }, { "name": "doctrine/collections", diff --git a/core/vendor/composer/installed.json b/core/vendor/composer/installed.json index d8f6af5..e5db1f5 100644 --- a/core/vendor/composer/installed.json +++ b/core/vendor/composer/installed.json @@ -135,77 +135,6 @@ ] }, { - "name": "doctrine/cache", - "version": "v1.3.1", - "version_normalized": "1.3.1.0", - "source": { - "type": "git", - "url": "https://github.com/doctrine/cache.git", - "reference": "cf483685798a72c93bf4206e3dd6358ea07d64e7" - }, - "dist": { - "type": "zip", - "url": "https://api.github.com/repos/doctrine/cache/zipball/cf483685798a72c93bf4206e3dd6358ea07d64e7", - "reference": "cf483685798a72c93bf4206e3dd6358ea07d64e7", - "shasum": "" - }, - "require": { - "php": ">=5.3.2" - }, - "conflict": { - "doctrine/common": ">2.2,<2.4" - }, - "require-dev": { - "phpunit/phpunit": ">=3.7", - "satooshi/php-coveralls": "~0.6" - }, - "time": "2014-09-17 14:24:04", - "type": "library", - "extra": { - "branch-alias": { - "dev-master": "1.4.x-dev" - } - }, - "installation-source": "dist", - "autoload": { - "psr-0": { - "Doctrine\\Common\\Cache\\": "lib/" - } - }, - "notification-url": "https://packagist.org/downloads/", - "license": [ - "MIT" - ], - "authors": [ - { - "name": "Roman Borschel", - "email": "roman@code-factory.org" - }, - { - "name": "Benjamin Eberlei", - "email": "kontakt@beberlei.de" - }, - { - "name": "Guilherme Blanco", - "email": "guilhermeblanco@gmail.com" - }, - { - "name": "Jonathan Wage", - "email": "jonwage@gmail.com" - }, - { - "name": "Johannes Schmitt", - "email": "schmittjoh@gmail.com" - } - ], - "description": "Caching library offering an object-oriented API for many cache backends", - "homepage": "http://www.doctrine-project.org", - "keywords": [ - "cache", - "caching" - ] - }, - { "name": "doctrine/annotations", "version": "v1.2.1", "version_normalized": "1.2.1.0", @@ -3561,5 +3490,77 @@ "validation", "validator" ] + }, + { + "name": "doctrine/cache", + "version": "v1.4.1", + "version_normalized": "1.4.1.0", + "source": { + "type": "git", + "url": "https://github.com/doctrine/cache.git", + "reference": "c9eadeb743ac6199f7eec423cb9426bc518b7b03" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/doctrine/cache/zipball/c9eadeb743ac6199f7eec423cb9426bc518b7b03", + "reference": "c9eadeb743ac6199f7eec423cb9426bc518b7b03", + "shasum": "" + }, + "require": { + "php": ">=5.3.2" + }, + "conflict": { + "doctrine/common": ">2.2,<2.4" + }, + "require-dev": { + "phpunit/phpunit": ">=3.7", + "predis/predis": "~1.0", + "satooshi/php-coveralls": "~0.6" + }, + "time": "2015-04-15 00:11:59", + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.5.x-dev" + } + }, + "installation-source": "dist", + "autoload": { + "psr-0": { + "Doctrine\\Common\\Cache\\": "lib/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Roman Borschel", + "email": "roman@code-factory.org" + }, + { + "name": "Benjamin Eberlei", + "email": "kontakt@beberlei.de" + }, + { + "name": "Guilherme Blanco", + "email": "guilhermeblanco@gmail.com" + }, + { + "name": "Jonathan Wage", + "email": "jonwage@gmail.com" + }, + { + "name": "Johannes Schmitt", + "email": "schmittjoh@gmail.com" + } + ], + "description": "Caching library offering an object-oriented API for many cache backends", + "homepage": "http://www.doctrine-project.org", + "keywords": [ + "cache", + "caching" + ] } ] diff --git a/core/vendor/doctrine/cache/.travis.yml b/core/vendor/doctrine/cache/.travis.yml index 28ec9b9..2952a48 100644 --- a/core/vendor/doctrine/cache/.travis.yml +++ b/core/vendor/doctrine/cache/.travis.yml @@ -13,13 +13,15 @@ services: - memcached - redis-server -before_script: +before_install: - sh -c "if [ $TRAVIS_PHP_VERSION != 'hhvm' ]; then pecl install riak-beta; fi" - sh -c "if [[ $TRAVIS_PHP_VERSION != 'hhvm' && `php-config --vernum` -ge 50500 ]] ; then pecl config-set preferred_state beta; printf "yes\n" | pecl install apcu ; else echo 'extension="apc.so"' >> ./tests/travis/php.ini ;fi" - composer self-update - - composer --prefer-source --dev install - sh -c "if [ $TRAVIS_PHP_VERSION != 'hhvm' ]; then phpenv config-add ./tests/travis/php.ini; fi" +install: + - composer --prefer-source --dev install + script: - ./vendor/bin/phpunit -c ./tests/travis/phpunit.travis.xml -v diff --git a/core/vendor/doctrine/cache/UPGRADE.md b/core/vendor/doctrine/cache/UPGRADE.md new file mode 100644 index 0000000..e1f8a50 --- /dev/null +++ b/core/vendor/doctrine/cache/UPGRADE.md @@ -0,0 +1,16 @@ +# Upgrade to 1.4 + +## Minor BC Break: `Doctrine\Common\Cache\FileCache#$extension` is now `private`. + +If you need to override the value of `Doctrine\Common\Cache\FileCache#$extension`, then use the +second parameter of `Doctrine\Common\Cache\FileCache#__construct()` instead of overriding +the property in your own implementation. + +## Minor BC Break: file based caches paths changed + +`Doctrine\Common\Cache\FileCache`, `Doctrine\Common\Cache\PhpFileCache` and +`Doctrine\Common\Cache\FilesystemCache` are using a different cache paths structure. + +If you rely on warmed up caches for deployments, consider that caches generated +with `doctrine/cache` `<1.4` are not compatible with the new directory structure, +and will be ignored. diff --git a/core/vendor/doctrine/cache/composer.json b/core/vendor/doctrine/cache/composer.json index 25b9de8..f3caa7a 100644 --- a/core/vendor/doctrine/cache/composer.json +++ b/core/vendor/doctrine/cache/composer.json @@ -17,7 +17,8 @@ }, "require-dev": { "phpunit/phpunit": ">=3.7", - "satooshi/php-coveralls": "~0.6" + "satooshi/php-coveralls": "~0.6", + "predis/predis": "~1.0" }, "conflict": { "doctrine/common": ">2.2,<2.4" @@ -27,7 +28,7 @@ }, "extra": { "branch-alias": { - "dev-master": "1.4.x-dev" + "dev-master": "1.5.x-dev" } } } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ApcCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ApcCache.php index 1f19db6..abd5e71 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ApcCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ApcCache.php @@ -75,9 +75,17 @@ protected function doFlush() /** * {@inheritdoc} */ + protected function doFetchMultiple(array $keys) + { + return apc_fetch($keys); + } + + /** + * {@inheritdoc} + */ protected function doGetStats() { - $info = apc_cache_info(); + $info = apc_cache_info('', true); $sma = apc_sma_info(); // @TODO - Temporary fix @see https://github.com/krakjoe/apcu/pull/42 diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php index e824377..31a0729 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php @@ -50,6 +50,7 @@ protected function doFetch($id) */ protected function doContains($id) { + // isset() is required for performance optimizations, to avoid unnecessary function calls to array_key_exists. return isset($this->data[$id]) || array_key_exists($id, $this->data); } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/Cache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/Cache.php index 0785f26..205a123 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/Cache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/Cache.php @@ -29,6 +29,7 @@ * @author Jonathan Wage * @author Roman Borschel * @author Fabio B. Silva + * @author Kévin Dunglas */ interface Cache { @@ -51,7 +52,7 @@ * * @return mixed The cached data or FALSE, if no cache entry exists for the given id. */ - function fetch($id); + public function fetch($id); /** * Tests if an entry exists in the cache. @@ -60,7 +61,7 @@ function fetch($id); * * @return boolean TRUE if a cache entry exists for the given cache id, FALSE otherwise. */ - function contains($id); + public function contains($id); /** * Puts data into the cache. @@ -72,7 +73,7 @@ function contains($id); * * @return boolean TRUE if the entry was successfully stored in the cache, FALSE otherwise. */ - function save($id, $data, $lifeTime = 0); + public function save($id, $data, $lifeTime = 0); /** * Deletes a cache entry. @@ -81,7 +82,7 @@ function save($id, $data, $lifeTime = 0); * * @return boolean TRUE if the cache entry was successfully deleted, FALSE otherwise. */ - function delete($id); + public function delete($id); /** * Retrieves cached information from the data store. @@ -107,5 +108,5 @@ function delete($id); * * @return array|null An associative array with server's statistics if available, NULL otherwise. */ - function getStats(); + public function getStats(); } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php index f896bc7..e911f61 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php @@ -29,7 +29,7 @@ * @author Roman Borschel * @author Fabio B. Silva */ -abstract class CacheProvider implements Cache +abstract class CacheProvider implements Cache, FlushableCache, ClearableCache, MultiGetCache { const DOCTRINE_NAMESPACE_CACHEKEY = 'DoctrineNamespaceCacheKey[%s]'; @@ -81,6 +81,27 @@ public function fetch($id) /** * {@inheritdoc} */ + public function fetchMultiple(array $keys) + { + // note: the array_combine() is in place to keep an association between our $keys and the $namespacedKeys + $namespacedKeys = array_combine($keys, array_map(array($this, 'getNamespacedId'), $keys)); + $items = $this->doFetchMultiple($namespacedKeys); + $foundItems = array(); + + // no internal array function supports this sort of mapping: needs to be iterative + // this filters and combines keys in one pass + foreach ($namespacedKeys as $requestedKey => $namespacedKey) { + if (isset($items[$namespacedKey])) { + $foundItems[$requestedKey] = $items[$namespacedKey]; + } + } + + return $foundItems; + } + + /** + * {@inheritdoc} + */ public function contains($id) { return $this->doContains($this->getNamespacedId($id)); @@ -111,9 +132,7 @@ public function getStats() } /** - * Flushes all cache entries. - * - * @return boolean TRUE if the cache entries were successfully flushed, FALSE otherwise. + * {@inheritDoc} */ public function flushAll() { @@ -121,9 +140,7 @@ public function flushAll() } /** - * Deletes all cache entries. - * - * @return boolean TRUE if the cache entries were successfully deleted, FALSE otherwise. + * {@inheritDoc} */ public function deleteAll() { @@ -185,6 +202,25 @@ private function getNamespaceVersion() } /** + * Default implementation of doFetchMultiple. Each driver that supports multi-get should owerwrite it. + * + * @param array $keys Array of keys to retrieve from cache + * @return array Array of values retrieved for the given keys. + */ + protected function doFetchMultiple(array $keys) + { + $returnValues = array(); + + foreach ($keys as $index => $key) { + if (false !== ($item = $this->doFetch($key))) { + $returnValues[$key] = $item; + } + } + + return $returnValues; + } + + /** * Fetches an entry from the cache. * * @param string $id The id of the cache entry to fetch. @@ -226,7 +262,7 @@ private function getNamespaceVersion() /** * Flushes all cache entries. * - * @return boolean TRUE if the cache entry was successfully deleted, FALSE otherwise. + * @return boolean TRUE if the cache entries were successfully flushed, FALSE otherwise. */ abstract protected function doFlush(); diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ChainCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ChainCache.php new file mode 100644 index 0000000..96c9b54 --- /dev/null +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ChainCache.php @@ -0,0 +1,147 @@ +. + */ + +namespace Doctrine\Common\Cache; + +/** + * Cache provider that allows to easily chain multiple cache providers + * + * @author Michaël Gallego + */ +class ChainCache extends CacheProvider +{ + /** + * @var CacheProvider[] + */ + private $cacheProviders = array(); + + /** + * Constructor + * + * @param CacheProvider[] $cacheProviders + */ + public function __construct($cacheProviders = array()) + { + $this->cacheProviders = $cacheProviders; + } + + /** + * {@inheritDoc} + */ + public function setNamespace($namespace) + { + parent::setNamespace($namespace); + + foreach ($this->cacheProviders as $cacheProvider) { + $cacheProvider->setNamespace($namespace); + } + } + + /** + * {@inheritDoc} + */ + protected function doFetch($id) + { + foreach ($this->cacheProviders as $key => $cacheProvider) { + if ($cacheProvider->doContains($id)) { + $value = $cacheProvider->doFetch($id); + + // We populate all the previous cache layers (that are assumed to be faster) + for ($subKey = $key - 1 ; $subKey >= 0 ; $subKey--) { + $this->cacheProviders[$subKey]->doSave($id, $value); + } + + return $value; + } + } + + return false; + } + + /** + * {@inheritDoc} + */ + protected function doContains($id) + { + foreach ($this->cacheProviders as $cacheProvider) { + if ($cacheProvider->doContains($id)) { + return true; + } + } + + return false; + } + + /** + * {@inheritDoc} + */ + protected function doSave($id, $data, $lifeTime = 0) + { + $stored = true; + + foreach ($this->cacheProviders as $cacheProvider) { + $stored = $cacheProvider->doSave($id, $data, $lifeTime) && $stored; + } + + return $stored; + } + + /** + * {@inheritDoc} + */ + protected function doDelete($id) + { + $deleted = true; + + foreach ($this->cacheProviders as $cacheProvider) { + $deleted = $cacheProvider->doDelete($id) && $deleted; + } + + return $deleted; + } + + /** + * {@inheritDoc} + */ + protected function doFlush() + { + $flushed = true; + + foreach ($this->cacheProviders as $cacheProvider) { + $flushed = $cacheProvider->doFlush() && $flushed; + } + + return $flushed; + } + + /** + * {@inheritDoc} + */ + protected function doGetStats() + { + // We return all the stats from all adapters + $stats = array(); + + foreach ($this->cacheProviders as $cacheProvider) { + $stats[] = $cacheProvider->doGetStats(); + } + + return $stats; + } +} diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ClearableCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ClearableCache.php new file mode 100644 index 0000000..f8b0161 --- /dev/null +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ClearableCache.php @@ -0,0 +1,37 @@ +. + */ + +namespace Doctrine\Common\Cache; + +/** + * Interface for cache that can be flushed. + * + * @link www.doctrine-project.org + * @since 1.4 + * @author Adirelle + */ +interface ClearableCache +{ + /** + * Deletes all cache entries. + * + * @return boolean TRUE if the cache entries were successfully deleted, FALSE otherwise. + */ + public function deleteAll(); +} diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FileCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FileCache.php index d91d0bc..243c28c 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FileCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FileCache.php @@ -37,19 +37,32 @@ /** * The cache file extension. * - * @var string|null + * @var string */ - protected $extension; + private $extension; + + /** + * @var string[] regular expressions for replacing disallowed characters in file name + */ + private $disallowedCharacterPatterns = array( + '/\-/', // replaced to disambiguate original `-` and `-` derived from replacements + '/[^a-zA-Z0-9\-_\[\]]/' // also excludes non-ascii chars (not supported, depending on FS) + ); + + /** + * @var string[] replacements for disallowed file characters + */ + private $replacementCharacters = array('__', '-'); /** * Constructor. * - * @param string $directory The cache directory. - * @param string|null $extension The cache file extension. + * @param string $directory The cache directory. + * @param string $extension The cache file extension. * * @throws \InvalidArgumentException */ - public function __construct($directory, $extension = null) + public function __construct($directory, $extension = '') { if ( ! is_dir($directory) && ! @mkdir($directory, 0777, true)) { throw new \InvalidArgumentException(sprintf( @@ -66,7 +79,7 @@ public function __construct($directory, $extension = null) } $this->directory = realpath($directory); - $this->extension = $extension ?: $this->extension; + $this->extension = (string) $extension; } /** @@ -96,12 +109,12 @@ public function getExtension() */ protected function getFilename($id) { - $hash = hash('sha256', $id); - $path = implode(str_split($hash, 16), DIRECTORY_SEPARATOR); - $path = $this->directory . DIRECTORY_SEPARATOR . $path; - $id = preg_replace('@[\\\/:"*?<>|]+@', '', $id); - - return $path . DIRECTORY_SEPARATOR . $id . $this->extension; + return $this->directory + . DIRECTORY_SEPARATOR + . implode(str_split(hash('sha256', $id), 2), DIRECTORY_SEPARATOR) + . DIRECTORY_SEPARATOR + . preg_replace($this->disallowedCharacterPatterns, $this->replacementCharacters, $id) + . $this->extension; } /** @@ -146,13 +159,65 @@ protected function doGetStats() } /** + * Create path if needed. + * + * @param string $path + * @return bool TRUE on success or if path already exists, FALSE if path cannot be created. + */ + private function createPathIfNeeded($path) + { + if ( ! is_dir($path)) { + if (false === @mkdir($path, 0777, true) && !is_dir($path)) { + return false; + } + } + + return true; + } + + /** + * Writes a string content to file in an atomic way. + * + * @param string $filename Path to the file where to write the data. + * @param string $content The content to write + * + * @return bool TRUE on success, FALSE if path cannot be created, if path is not writable or an any other error. + */ + protected function writeFile($filename, $content) + { + $filepath = pathinfo($filename, PATHINFO_DIRNAME); + + if ( ! $this->createPathIfNeeded($filepath)) { + return false; + } + + if ( ! is_writable($filepath)) { + return false; + } + + $tmpFile = tempnam($filepath, 'swap'); + + if (file_put_contents($tmpFile, $content) !== false) { + if (@rename($tmpFile, $filename)) { + @chmod($filename, 0666 & ~umask()); + + return true; + } + + @unlink($tmpFile); + } + + return false; + } + + /** * @return \Iterator */ private function getIterator() { - $pattern = '/^.+\\' . $this->extension . '$/i'; - $iterator = new \RecursiveDirectoryIterator($this->directory); - $iterator = new \RecursiveIteratorIterator($iterator); - return new \RegexIterator($iterator, $pattern); + return new \RegexIterator( + new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->directory)), + '/^.+' . preg_quote($this->extension, '/') . '$/i' + ); } } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FilesystemCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FilesystemCache.php index 07eda8e..6b44aa0 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FilesystemCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FilesystemCache.php @@ -32,7 +32,10 @@ class FilesystemCache extends FileCache /** * {@inheritdoc} */ - protected $extension = self::EXTENSION; + public function __construct($directory, $extension = self::EXTENSION) + { + parent::__construct($directory, $extension); + } /** * {@inheritdoc} @@ -100,26 +103,9 @@ protected function doSave($id, $data, $lifeTime = 0) $lifeTime = time() + $lifeTime; } - $data = serialize($data); - $filename = $this->getFilename($id); - $filepath = pathinfo($filename, PATHINFO_DIRNAME); - - if ( ! is_dir($filepath)) { - if (false === @mkdir($filepath, 0777, true) && !is_dir($filepath)) { - return false; - } - } elseif ( ! is_writable($filepath)) { - return false; - } - - $tmpFile = tempnam($filepath, basename($filename)); - - if ((file_put_contents($tmpFile, $lifeTime . PHP_EOL . $data) !== false) && @rename($tmpFile, $filename)) { - @chmod($filename, 0666 & ~umask()); - - return true; - } + $data = serialize($data); + $filename = $this->getFilename($id); - return false; + return $this->writeFile($filename, $lifeTime . PHP_EOL . $data); } } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FlushableCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FlushableCache.php new file mode 100644 index 0000000..817cee7 --- /dev/null +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/FlushableCache.php @@ -0,0 +1,37 @@ +. + */ + +namespace Doctrine\Common\Cache; + +/** + * Interface for cache that can be flushed. + * + * @link www.doctrine-project.org + * @since 1.4 + * @author Adirelle + */ +interface FlushableCache +{ + /** + * Flushes all cache entries. + * + * @return boolean TRUE if the cache entries were successfully flushed, FALSE otherwise. + */ + public function flushAll(); +} diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcacheCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcacheCache.php index f839a65..c5098fd 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcacheCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcacheCache.php @@ -74,7 +74,11 @@ protected function doFetch($id) */ protected function doContains($id) { - return (bool) $this->memcache->get($id); + $flags = null; + $this->memcache->get($id, $flags); + + //if memcache has changed the value of "flags", it means the value exists + return ($flags !== null); } /** diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcachedCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcachedCache.php index f7e5500..040c26c 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcachedCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MemcachedCache.php @@ -72,6 +72,14 @@ protected function doFetch($id) /** * {@inheritdoc} */ + protected function doFetchMultiple(array $keys) + { + return $this->memcached->getMulti($keys); + } + + /** + * {@inheritdoc} + */ protected function doContains($id) { return (false !== $this->memcached->get($id)); diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MultiGetCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MultiGetCache.php new file mode 100644 index 0000000..df7146d --- /dev/null +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/MultiGetCache.php @@ -0,0 +1,39 @@ +. + */ + +namespace Doctrine\Common\Cache; + +/** + * Interface for cache drivers that allows to get many items at once. + * + * @link www.doctrine-project.org + * @since 1.4 + * @author Asmir Mustafic + */ +interface MultiGetCache +{ + /** + * Returns an associative array of values for keys is found in cache. + * + * @param string[] $keys Array of keys to retrieve from cache + * @return mixed[] Array of retrieved values, indexed by the specified keys. + * Values that couldn't be retrieved are not contained in this array. + */ + function fetchMultiple(array $keys); +} diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PhpFileCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PhpFileCache.php index f017d83..12dda5a 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PhpFileCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PhpFileCache.php @@ -29,24 +29,25 @@ class PhpFileCache extends FileCache { const EXTENSION = '.doctrinecache.php'; - /** + /** * {@inheritdoc} */ - protected $extension = self::EXTENSION; + public function __construct($directory, $extension = self::EXTENSION) + { + parent::__construct($directory, $extension); + } /** * {@inheritdoc} */ protected function doFetch($id) { - $filename = $this->getFilename($id); + $value = $this->includeFileForId($id); - if ( ! is_file($filename)) { + if (! $value) { return false; } - $value = include $filename; - if ($value['lifetime'] !== 0 && $value['lifetime'] < time()) { return false; } @@ -59,14 +60,12 @@ protected function doFetch($id) */ protected function doContains($id) { - $filename = $this->getFilename($id); + $value = $this->includeFileForId($id); - if ( ! is_file($filename)) { + if (! $value) { return false; } - $value = include $filename; - return $value['lifetime'] === 0 || $value['lifetime'] > time(); } @@ -87,12 +86,7 @@ protected function doSave($id, $data, $lifeTime = 0) ); } - $filename = $this->getFilename($id); - $filepath = pathinfo($filename, PATHINFO_DIRNAME); - - if ( ! is_dir($filepath)) { - mkdir($filepath, 0777, true); - } + $filename = $this->getFilename($id); $value = array( 'lifetime' => $lifeTime, @@ -102,6 +96,25 @@ protected function doSave($id, $data, $lifeTime = 0) $value = var_export($value, true); $code = sprintf('writeFile($filename, $code); + } + + /** + * @param string $id + * + * @return array|false + */ + private function includeFileForId($id) + { + $fileName = $this->getFilename($id); + + // note: error suppression is still faster than `file_exists`, `is_file` and `is_readable` + $value = @include $fileName; + + if (! isset($value['lifetime'])) { + return false; + } + + return $value; } } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PredisCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PredisCache.php new file mode 100644 index 0000000..887f1ba --- /dev/null +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/PredisCache.php @@ -0,0 +1,106 @@ + + */ +class PredisCache extends CacheProvider +{ + /** + * @var Client + */ + private $client; + + /** + * @param Client $client + * + * @return void + */ + public function __construct(Client $client) + { + $this->client = $client; + } + + /** + * {@inheritdoc} + */ + protected function doFetch($id) + { + $result = $this->client->get($id); + if (null === $result) { + return false; + } + + return $result; + } + + /** + * {@inheritdoc} + */ + protected function doFetchMultiple(array $keys) + { + $fetchedItems = call_user_func_array(array($this->client, 'mget'), $keys); + + return array_filter(array_combine($keys, $fetchedItems)); + } + /** + * {@inheritdoc} + */ + protected function doContains($id) + { + return $this->client->exists($id); + } + + /** + * {@inheritdoc} + */ + protected function doSave($id, $data, $lifeTime = 0) + { + if ($lifeTime > 0) { + $response = $this->client->setex($id, $lifeTime, $data); + } else { + $response = $this->client->set($id, $data); + } + + return $response === true || $response == 'OK'; + } + + /** + * {@inheritdoc} + */ + protected function doDelete($id) + { + return $this->client->del($id) > 0; + } + + /** + * {@inheritdoc} + */ + protected function doFlush() + { + $response = $this->client->flushdb(); + + return $response === true || $response == 'OK'; + } + + /** + * {@inheritdoc} + */ + protected function doGetStats() + { + $info = $this->client->info(); + + return array( + Cache::STATS_HITS => false, + Cache::STATS_MISSES => false, + Cache::STATS_UPTIME => $info['Server']['uptime_in_seconds'], + Cache::STATS_MEMORY_USAGE => $info['Memory']['used_memory'], + Cache::STATS_MEMORY_AVAILABLE => false + ); + } +} diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/RedisCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/RedisCache.php index 8d00a3b..bffa022 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/RedisCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/RedisCache.php @@ -69,6 +69,22 @@ protected function doFetch($id) /** * {@inheritdoc} */ + protected function doFetchMultiple(array $keys) + { + $returnValues = array(); + $fetchedItems = $this->redis->mget($keys); + foreach ($keys as $key) { + if (isset($fetchedItems[$key])) { + $returnValues[$key] = $fetchedItems[$key]; + } + } + + return $returnValues; + } + + /** + * {@inheritdoc} + */ protected function doContains($id) { return $this->redis->exists($id); @@ -126,6 +142,9 @@ protected function doGetStats() */ protected function getSerializerValue() { + if (defined('HHVM_VERSION')) { + return Redis::SERIALIZER_PHP; + } return defined('Redis::SERIALIZER_IGBINARY') ? Redis::SERIALIZER_IGBINARY : Redis::SERIALIZER_PHP; } } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/SQLite3Cache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/SQLite3Cache.php new file mode 100644 index 0000000..b12978c --- /dev/null +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/SQLite3Cache.php @@ -0,0 +1,219 @@ +. + */ + +namespace Doctrine\Common\Cache; + +use SQLite3; +use SQLite3Result; + +/** + * SQLite3 cache provider. + * + * @since 1.4 + * @author Jake Bell + */ +class SQLite3Cache extends CacheProvider +{ + /** + * The ID field will store the cache key. + */ + const ID_FIELD = 'k'; + + /** + * The data field will store the serialized PHP value. + */ + const DATA_FIELD = 'd'; + + /** + * The expiration field will store a date value indicating when the + * cache entry should expire. + */ + const EXPIRATION_FIELD = 'e'; + + /** + * @var SQLite3 + */ + private $sqlite; + + /** + * @var string + */ + private $table; + + /** + * Constructor. + * + * Calling the constructor will ensure that the database file and table + * exist and will create both if they don't. + * + * @param SQLite3 $sqlite + * @param string $table + */ + public function __construct(SQLite3 $sqlite, $table) + { + $this->sqlite = $sqlite; + $this->table = (string) $table; + + list($id, $data, $exp) = $this->getFields(); + + return $this->sqlite->exec(sprintf( + 'CREATE TABLE IF NOT EXISTS %s(%s TEXT PRIMARY KEY NOT NULL, %s BLOB, %s INTEGER)', + $table, + $id, + $data, + $exp + )); + } + + /** + * {@inheritdoc} + */ + protected function doFetch($id) + { + if ($item = $this->findById($id)) { + return unserialize($item[self::DATA_FIELD]); + } + + return false; + } + + /** + * {@inheritdoc} + */ + protected function doContains($id) + { + return (boolean) $this->findById($id, false); + } + + /** + * {@inheritdoc} + */ + protected function doSave($id, $data, $lifeTime = 0) + { + $statement = $this->sqlite->prepare(sprintf( + 'INSERT OR REPLACE INTO %s (%s) VALUES (:id, :data, :expire)', + $this->table, + implode(',', $this->getFields()) + )); + + $statement->bindValue(':id', $id); + $statement->bindValue(':data', serialize($data), SQLITE3_BLOB); + $statement->bindValue(':expire', $lifeTime > 0 ? time() + $lifeTime : null); + + return $statement->execute() instanceof SQLite3Result; + } + + /** + * {@inheritdoc} + */ + protected function doDelete($id) + { + list($idField) = $this->getFields(); + + $statement = $this->sqlite->prepare(sprintf( + 'DELETE FROM %s WHERE %s = :id', + $this->table, + $idField + )); + + $statement->bindValue(':id', $id); + + return $statement->execute() instanceof SQLite3Result; + } + + /** + * {@inheritdoc} + */ + protected function doFlush() + { + return $this->sqlite->exec(sprintf('DELETE FROM %s', $this->table)); + } + + /** + * {@inheritdoc} + */ + protected function doGetStats() + { + // no-op. + } + + /** + * Find a single row by ID. + * + * @param mixed $id + * @param boolean $includeData + * + * @return array|null + */ + private function findById($id, $includeData = true) + { + list($idField) = $fields = $this->getFields(); + + if (!$includeData) { + $key = array_search(static::DATA_FIELD, $fields); + unset($fields[$key]); + } + + $statement = $this->sqlite->prepare(sprintf( + 'SELECT %s FROM %s WHERE %s = :id LIMIT 1', + implode(',', $fields), + $this->table, + $idField + )); + + $statement->bindValue(':id', $id, SQLITE3_TEXT); + + $item = $statement->execute()->fetchArray(SQLITE3_ASSOC); + + if ($item === false) { + return null; + } + + if ($this->isExpired($item)) { + $this->doDelete($id); + + return null; + } + + return $item; + } + + /** + * Gets an array of the fields in our table. + * + * @return array + */ + private function getFields() + { + return array(static::ID_FIELD, static::DATA_FIELD, static::EXPIRATION_FIELD); + } + + /** + * Check if the item is expired. + * + * @param array $item + * @return boolean + */ + private function isExpired(array $item) + { + return isset($item[static::EXPIRATION_FIELD]) && + $item[self::EXPIRATION_FIELD] !== null && + $item[self::EXPIRATION_FIELD] < time(); + } +} diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/VoidCache.php similarity index 66% copy from core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php copy to core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/VoidCache.php index e824377..65e8456 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/ArrayCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/VoidCache.php @@ -20,74 +20,59 @@ namespace Doctrine\Common\Cache; /** - * Array cache driver. + * Void cache driver. The cache could be of use in tests where you don`t need to cache anything. * * @link www.doctrine-project.org - * @since 2.0 - * @author Benjamin Eberlei - * @author Guilherme Blanco - * @author Jonathan Wage - * @author Roman Borschel - * @author David Abdemoulaie + * @since 1.5 + * @author Kotlyar Maksim */ -class ArrayCache extends CacheProvider +class VoidCache extends CacheProvider { /** - * @var array $data - */ - private $data = array(); - - /** - * {@inheritdoc} + * {@inheritDoc} */ protected function doFetch($id) { - return $this->doContains($id) ? $this->data[$id] : false; + return false; } /** - * {@inheritdoc} + * {@inheritDoc} */ protected function doContains($id) { - return isset($this->data[$id]) || array_key_exists($id, $this->data); + return false; } /** - * {@inheritdoc} + * {@inheritDoc} */ protected function doSave($id, $data, $lifeTime = 0) { - $this->data[$id] = $data; - return true; } /** - * {@inheritdoc} + * {@inheritDoc} */ protected function doDelete($id) { - unset($this->data[$id]); - return true; } /** - * {@inheritdoc} + * {@inheritDoc} */ protected function doFlush() { - $this->data = array(); - return true; } /** - * {@inheritdoc} + * {@inheritDoc} */ protected function doGetStats() { - return null; + return; } } diff --git a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/XcacheCache.php b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/XcacheCache.php index 833b02a..a2c4ca5 100644 --- a/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/XcacheCache.php +++ b/core/vendor/doctrine/cache/lib/Doctrine/Common/Cache/XcacheCache.php @@ -71,7 +71,7 @@ protected function doFlush() { $this->checkAuthorization(); - xcache_clear_cache(XC_TYPE_VAR, 0); + xcache_clear_cache(XC_TYPE_VAR); return true; } @@ -86,7 +86,10 @@ protected function doFlush() protected function checkAuthorization() { if (ini_get('xcache.admin.enable_auth')) { - throw new \BadMethodCallException('To use all features of \Doctrine\Common\Cache\XcacheCache, you must set "xcache.admin.enable_auth" to "Off" in your php.ini.'); + throw new \BadMethodCallException( + 'To use all features of \Doctrine\Common\Cache\XcacheCache, ' + . 'you must set "xcache.admin.enable_auth" to "Off" in your php.ini.' + ); } } diff --git a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/CacheTest.php b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/CacheTest.php index 59ca4dc..c40a6ce 100644 --- a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/CacheTest.php +++ b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/CacheTest.php @@ -29,6 +29,57 @@ public function testBasicCrudOperations($value) $this->assertFalse($cache->contains('key')); } + public function testFetchMulti() + { + $cache = $this->_getCacheDriver(); + + // Test saving some values, checking if it exists, and fetching it back with multiGet + $this->assertTrue($cache->save('key1', 'value1')); + $this->assertTrue($cache->save('key2', 'value2')); + + $this->assertEquals( + array('key1' => 'value1', 'key2' => 'value2'), + $cache->fetchMultiple(array('key1', 'key2')) + ); + $this->assertEquals( + array('key1' => 'value1', 'key2' => 'value2'), + $cache->fetchMultiple(array('key1', 'key3', 'key2')) + ); + $this->assertEquals( + array('key1' => 'value1', 'key2' => 'value2'), + $cache->fetchMultiple(array('key1', 'key2', 'key3')) + ); + } + + public function testFetchMultiWillFilterNonRequestedKeys() + { + /* @var $cache \Doctrine\Common\Cache\CacheProvider|\PHPUnit_Framework_MockObject_MockObject */ + $cache = $this->getMockForAbstractClass( + 'Doctrine\Common\Cache\CacheProvider', + array(), + '', + true, + true, + true, + array('doFetchMultiple') + ); + + $cache + ->expects($this->once()) + ->method('doFetchMultiple') + ->will($this->returnValue(array( + '[foo][]' => 'bar', + '[bar][]' => 'baz', + '[baz][]' => 'tab', + ))); + + $this->assertEquals( + array('foo' => 'bar', 'bar' => 'baz'), + $cache->fetchMultiple(array('foo', 'bar')) + ); + } + + public function provideCrudValues() { return array( @@ -224,6 +275,38 @@ public function testFetchMissShouldReturnFalse() } /** + * Check to see that, even if the user saves a value that can be interpreted as false, + * the cache adapter will still recognize its existence there. + * + * @dataProvider falseCastedValuesProvider + */ + public function testFalseCastedValues($value) + { + $cache = $this->_getCacheDriver(); + + $this->assertTrue($cache->save('key', $value)); + $this->assertTrue($cache->contains('key')); + $this->assertEquals($value, $cache->fetch('key')); + } + + /** + * The following values get converted to FALSE if you cast them to a boolean. + * @see http://php.net/manual/en/types.comparisons.php + */ + public function falseCastedValuesProvider() + { + return array( + array(false), + array(null), + array(array()), + array('0'), + array(0), + array(0.0), + array('') + ); + } + + /** * Return whether multiple cache providers share the same storage. * * This is used for skipping certain tests for shared storage behavior. diff --git a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/ChainCacheTest.php b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/ChainCacheTest.php new file mode 100644 index 0000000..46d78c1 --- /dev/null +++ b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/ChainCacheTest.php @@ -0,0 +1,94 @@ +_getCacheDriver(); + $stats = $cache->getStats(); + + $this->assertInternalType('array', $stats); + } + + public function testOnlyFetchFirstOne() + { + $cache1 = new ArrayCache(); + $cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider'); + + $cache2->expects($this->never())->method('doFetch'); + + $chainCache = new ChainCache(array($cache1, $cache2)); + $chainCache->save('id', 'bar'); + + $this->assertEquals('bar', $chainCache->fetch('id')); + } + + public function testFetchPropagateToFastestCache() + { + $cache1 = new ArrayCache(); + $cache2 = new ArrayCache(); + + $cache2->save('bar', 'value'); + + $chainCache = new ChainCache(array($cache1, $cache2)); + + $this->assertFalse($cache1->contains('bar')); + + $result = $chainCache->fetch('bar'); + + $this->assertEquals('value', $result); + $this->assertTrue($cache2->contains('bar')); + } + + public function testNamespaceIsPropagatedToAllProviders() + { + $cache1 = new ArrayCache(); + $cache2 = new ArrayCache(); + + $chainCache = new ChainCache(array($cache1, $cache2)); + $chainCache->setNamespace('bar'); + + $this->assertEquals('bar', $cache1->getNamespace()); + $this->assertEquals('bar', $cache2->getNamespace()); + } + + public function testDeleteToAllProviders() + { + $cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider'); + $cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider'); + + $cache1->expects($this->once())->method('doDelete'); + $cache2->expects($this->once())->method('doDelete'); + + $chainCache = new ChainCache(array($cache1, $cache2)); + $chainCache->delete('bar'); + } + + public function testFlushToAllProviders() + { + $cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider'); + $cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider'); + + $cache1->expects($this->once())->method('doFlush'); + $cache2->expects($this->once())->method('doFlush'); + + $chainCache = new ChainCache(array($cache1, $cache2)); + $chainCache->flushAll(); + } + + protected function isSharedStorage() + { + return false; + } +} \ No newline at end of file diff --git a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/FileCacheTest.php b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/FileCacheTest.php index 6f9df81..8868321 100644 --- a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/FileCacheTest.php +++ b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/FileCacheTest.php @@ -2,6 +2,8 @@ namespace Doctrine\Tests\Common\Cache; +use Doctrine\Common\Cache\Cache; + /** * @group DCOM-101 */ @@ -25,16 +27,19 @@ public function getProviderFileName() { return array( //The characters :\/<>"*?| are not valid in Windows filenames. - array('key:1', 'key1'), - array('key\2', 'key2'), - array('key/3', 'key3'), - array('key<4', 'key4'), - array('key>5', 'key5'), - array('key"6', 'key6'), - array('key*7', 'key7'), - array('key?8', 'key8'), - array('key|9', 'key9'), - array('key[0]','key[0]'), + array('key:1', 'key-1'), + array('key\2', 'key-2'), + array('key/3', 'key-3'), + array('key<4', 'key-4'), + array('key>5', 'key-5'), + array('key"6', 'key-6'), + array('key*7', 'key-7'), + array('key?8', 'key-8'), + array('key|9', 'key-9'), + array('key[10]', 'key[10]'), + array('keyä11', 'key--11'), + array('../key12', '---key12'), + array('key-13', 'key__13'), ); } @@ -56,15 +61,19 @@ public function testInvalidFilename($key, $expected) public function testFilenameCollision() { - $data['key:0'] = 'key0'; - $data['key\0'] = 'key0'; - $data['key/0'] = 'key0'; - $data['key<0'] = 'key0'; - $data['key>0'] = 'key0'; - $data['key"0'] = 'key0'; - $data['key*0'] = 'key0'; - $data['key?0'] = 'key0'; - $data['key|0'] = 'key0'; + $data = array( + 'key:0' => 'key-0', + 'key\0' => 'key-0', + 'key/0' => 'key-0', + 'key<0' => 'key-0', + 'key>0' => 'key-0', + 'key"0' => 'key-0', + 'key*0' => 'key-0', + 'key?0' => 'key-0', + 'key|0' => 'key-0', + 'key-0' => 'key__0', + 'keyä0' => 'key--0', + ); $paths = array(); $cache = $this->driver; @@ -88,10 +97,11 @@ public function testFilenameShouldCreateThePathWithFourSubDirectories() $cache = $this->driver; $method = new \ReflectionMethod($cache, 'getFilename'); $key = 'item-key'; - $expectedDir[] = '84e0e2e893febb73'; - $expectedDir[] = '7a0fee0c89d53f4b'; - $expectedDir[] = 'b7fcb44c57cdf3d3'; - $expectedDir[] = '2ce7363f5d597760'; + $expectedDir = array( + '84', 'e0', 'e2', 'e8', '93', 'fe', 'bb', '73', '7a', '0f', 'ee', + '0c', '89', 'd5', '3f', '4b', 'b7', 'fc', 'b4', '4c', '57', 'cd', + 'f3', 'd3', '2c', 'e7', '36', '3f', '5d', '59', '77', '60' + ); $expectedDir = implode(DIRECTORY_SEPARATOR, $expectedDir); $method->setAccessible(true); @@ -100,8 +110,52 @@ public function testFilenameShouldCreateThePathWithFourSubDirectories() $filename = pathinfo($path, PATHINFO_FILENAME); $dirname = pathinfo($path, PATHINFO_DIRNAME); - $this->assertEquals('item-key', $filename); + $this->assertEquals('item__key', $filename); $this->assertEquals(DIRECTORY_SEPARATOR . $expectedDir, $dirname); - $this->assertEquals(DIRECTORY_SEPARATOR . $expectedDir . DIRECTORY_SEPARATOR . $key, $path); + $this->assertEquals(DIRECTORY_SEPARATOR . $expectedDir . DIRECTORY_SEPARATOR . 'item__key', $path); + } + + public function testFileExtensionCorrectlyEscaped() + { + $driver1 = $this->getMock( + 'Doctrine\Common\Cache\FileCache', + array('doFetch', 'doContains', 'doSave'), + array(__DIR__, '.*') + ); + $driver2 = $this->getMock( + 'Doctrine\Common\Cache\FileCache', + array('doFetch', 'doContains', 'doSave'), + array(__DIR__, '.php') + ); + + $doGetStats = new \ReflectionMethod($driver1, 'doGetStats'); + + $doGetStats->setAccessible(true); + + $stats1 = $doGetStats->invoke($driver1); + $stats2 = $doGetStats->invoke($driver2); + + $this->assertSame(0, $stats1[Cache::STATS_MEMORY_USAGE]); + $this->assertGreaterThan(0, $stats2[Cache::STATS_MEMORY_USAGE]); + } + + /** + * @group DCOM-266 + */ + public function testFileExtensionSlashCorrectlyEscaped() + { + $driver = $this->getMock( + 'Doctrine\Common\Cache\FileCache', + array('doFetch', 'doContains', 'doSave'), + array(__DIR__ . '/../', '/' . basename(__FILE__)) + ); + + $doGetStats = new \ReflectionMethod($driver, 'doGetStats'); + + $doGetStats->setAccessible(true); + + $stats = $doGetStats->invoke($driver); + + $this->assertGreaterThan(0, $stats[Cache::STATS_MEMORY_USAGE]); } -} \ No newline at end of file +} diff --git a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php index 071329f..2028acc 100644 --- a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php +++ b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php @@ -53,4 +53,18 @@ protected function _getCacheDriver() $driver->setMemcached($this->memcached); return $driver; } + + /** + * {@inheritDoc} + * + * @dataProvider falseCastedValuesProvider + */ + public function testFalseCastedValues($value) + { + if (false === $value) { + $this->markTestIncomplete('Memcached currently doesn\'t support saving `false` values. '); + } + + parent::testFalseCastedValues($value); + } } diff --git a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/PredisCacheTest.php b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/PredisCacheTest.php new file mode 100644 index 0000000..61650ec --- /dev/null +++ b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/PredisCacheTest.php @@ -0,0 +1,48 @@ +client = new Client(); + + try { + $this->client->connect(); + } catch (ConnectionException $e) { + $this->markTestSkipped('The ' . __CLASS__ .' requires the use of redis'); + } + } + + /** + * @return PredisCache + */ + protected function _getCacheDriver() + { + return new PredisCache($this->client); + } + + /** + * {@inheritDoc} + * + * @dataProvider falseCastedValuesProvider + */ + public function testFalseCastedValues($value) + { + if (array() === $value) { + $this->markTestIncomplete( + 'Predis currently doesn\'t support saving empty array values. ' + . 'See https://github.com/nrk/predis/issues/241' + ); + } + + parent::testFalseCastedValues($value); + } +} diff --git a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/SQLite3CacheTest.php b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/SQLite3CacheTest.php new file mode 100644 index 0000000..44ccce9 --- /dev/null +++ b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/SQLite3CacheTest.php @@ -0,0 +1,48 @@ +file = tempnam(null, 'doctrine-cache-test-'); + unlink($this->file); + $this->sqlite = new SQLite3($this->file); + } + + protected function tearDown() + { + $this->sqlite = null; // DB must be closed before + unlink($this->file); + } + + public function testGetStats() + { + $this->assertNull($this->_getCacheDriver()->getStats()); + } + + public function testFetchSingle() + { + $id = uniqid('sqlite3_id_'); + $data = "\0"; // produces null bytes in serialized format + + $this->_getCacheDriver()->save($id, $data, 30); + + $this->assertEquals($data, $this->_getCacheDriver()->fetch($id)); + } + + protected function _getCacheDriver() + { + return new SQLite3Cache($this->sqlite, 'test_table'); + } +} diff --git a/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/VoidCacheTest.php b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/VoidCacheTest.php new file mode 100644 index 0000000..ca87f16 --- /dev/null +++ b/core/vendor/doctrine/cache/tests/Doctrine/Tests/Common/Cache/VoidCacheTest.php @@ -0,0 +1,51 @@ +assertFalse($cache->contains('foo')); + $this->assertFalse($cache->contains('bar')); + } + + public function testShouldAlwaysReturnFalseOnFetch() + { + $cache = new VoidCache(); + + $this->assertFalse($cache->fetch('foo')); + $this->assertFalse($cache->fetch('bar')); + } + + public function testShouldAlwaysReturnTrueOnSaveButNotStoreAnything() + { + $cache = new VoidCache(); + + $this->assertTrue($cache->save('foo', 'fooVal')); + + $this->assertFalse($cache->contains('foo')); + $this->assertFalse($cache->fetch('foo')); + } + + public function testShouldAlwaysReturnTrueOnDelete() + { + $cache = new VoidCache(); + + $this->assertTrue($cache->delete('foo')); + } + + public function testShouldAlwaysReturnNullOnGetStatus() + { + $cache = new VoidCache(); + + $this->assertNull($cache->getStats()); + } +}