diff options
Diffstat (limited to 'vendor/guzzle/guzzle/src/Guzzle/Cache')
9 files changed, 434 insertions, 0 deletions
diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/AbstractCacheAdapter.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/AbstractCacheAdapter.php new file mode 100644 index 0000000..a5c5271 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/AbstractCacheAdapter.php @@ -0,0 +1,21 @@ +<?php + +namespace Guzzle\Cache; + +/** + * Abstract cache adapter + */ +abstract class AbstractCacheAdapter implements CacheAdapterInterface +{ + protected $cache; + + /** + * Get the object owned by the adapter + * + * @return mixed + */ + public function getCacheObject() + { + return $this->cache; + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/CacheAdapterFactory.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/CacheAdapterFactory.php new file mode 100644 index 0000000..94e6234 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/CacheAdapterFactory.php @@ -0,0 +1,117 @@ +<?php + +namespace Guzzle\Cache; + +use Doctrine\Common\Cache\Cache; +use Guzzle\Common\Version; +use Guzzle\Common\Exception\InvalidArgumentException; +use Guzzle\Common\Exception\RuntimeException; +use Guzzle\Common\FromConfigInterface; +use Zend\Cache\Storage\StorageInterface; + +/** + * Generates cache adapters from any number of known cache implementations + */ +class CacheAdapterFactory implements FromConfigInterface +{ + /** + * Create a Guzzle cache adapter based on an array of options + * + * @param mixed $cache Cache value + * + * @return CacheAdapterInterface + * @throws InvalidArgumentException + */ + public static function fromCache($cache) + { + if (!is_object($cache)) { + throw new InvalidArgumentException('Cache must be one of the known cache objects'); + } + + if ($cache instanceof CacheAdapterInterface) { + return $cache; + } elseif ($cache instanceof Cache) { + return new DoctrineCacheAdapter($cache); + } elseif ($cache instanceof StorageInterface) { + return new Zf2CacheAdapter($cache); + } else { + throw new InvalidArgumentException('Unknown cache type: ' . get_class($cache)); + } + } + + /** + * Create a Guzzle cache adapter based on an array of options + * + * @param array $config Array of configuration options + * + * @return CacheAdapterInterface + * @throws InvalidArgumentException + * @deprecated This will be removed in a future version + * @codeCoverageIgnore + */ + public static function factory($config = array()) + { + Version::warn(__METHOD__ . ' is deprecated'); + if (!is_array($config)) { + throw new InvalidArgumentException('$config must be an array'); + } + + if (!isset($config['cache.adapter']) && !isset($config['cache.provider'])) { + $config['cache.adapter'] = 'Guzzle\Cache\NullCacheAdapter'; + $config['cache.provider'] = null; + } else { + // Validate that the options are valid + foreach (array('cache.adapter', 'cache.provider') as $required) { + if (!isset($config[$required])) { + throw new InvalidArgumentException("{$required} is a required CacheAdapterFactory option"); + } + if (is_string($config[$required])) { + // Convert dot notation to namespaces + $config[$required] = str_replace('.', '\\', $config[$required]); + if (!class_exists($config[$required])) { + throw new InvalidArgumentException("{$config[$required]} is not a valid class for {$required}"); + } + } + } + // Instantiate the cache provider + if (is_string($config['cache.provider'])) { + $args = isset($config['cache.provider.args']) ? $config['cache.provider.args'] : null; + $config['cache.provider'] = self::createObject($config['cache.provider'], $args); + } + } + + // Instantiate the cache adapter using the provider and options + if (is_string($config['cache.adapter'])) { + $args = isset($config['cache.adapter.args']) ? $config['cache.adapter.args'] : array(); + array_unshift($args, $config['cache.provider']); + $config['cache.adapter'] = self::createObject($config['cache.adapter'], $args); + } + + return $config['cache.adapter']; + } + + /** + * Create a class using an array of constructor arguments + * + * @param string $className Class name + * @param array $args Arguments for the class constructor + * + * @return mixed + * @throws RuntimeException + * @deprecated + * @codeCoverageIgnore + */ + private static function createObject($className, array $args = null) + { + try { + if (!$args) { + return new $className; + } else { + $c = new \ReflectionClass($className); + return $c->newInstanceArgs($args); + } + } catch (\Exception $e) { + throw new RuntimeException($e->getMessage(), $e->getCode(), $e); + } + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/CacheAdapterInterface.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/CacheAdapterInterface.php new file mode 100644 index 0000000..970c9e2 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/CacheAdapterInterface.php @@ -0,0 +1,55 @@ +<?php + +namespace Guzzle\Cache; + +/** + * Interface for cache adapters. + * + * Cache adapters allow Guzzle to utilize various frameworks for caching HTTP responses. + * + * @link http://www.doctrine-project.org/ Inspired by Doctrine 2 + */ +interface CacheAdapterInterface +{ + /** + * Test if an entry exists in the cache. + * + * @param string $id cache id The cache id of the entry to check for. + * @param array $options Array of cache adapter options + * + * @return bool Returns TRUE if a cache entry exists for the given cache id, FALSE otherwise. + */ + public function contains($id, array $options = null); + + /** + * Deletes a cache entry. + * + * @param string $id cache id + * @param array $options Array of cache adapter options + * + * @return bool TRUE on success, FALSE on failure + */ + public function delete($id, array $options = null); + + /** + * Fetches an entry from the cache. + * + * @param string $id cache id The id of the cache entry to fetch. + * @param array $options Array of cache adapter options + * + * @return string The cached data or FALSE, if no cache entry exists for the given id. + */ + public function fetch($id, array $options = null); + + /** + * Puts data into the cache. + * + * @param string $id The cache id + * @param string $data The cache entry/data + * @param int|bool $lifeTime The lifetime. If != false, sets a specific lifetime for this cache entry + * @param array $options Array of cache adapter options + * + * @return bool TRUE if the entry was successfully stored in the cache, FALSE otherwise. + */ + public function save($id, $data, $lifeTime = false, array $options = null); +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/ClosureCacheAdapter.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/ClosureCacheAdapter.php new file mode 100644 index 0000000..c7a3df4 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/ClosureCacheAdapter.php @@ -0,0 +1,57 @@ +<?php + +namespace Guzzle\Cache; + +/** + * Cache adapter that defers to closures for implementation + */ +class ClosureCacheAdapter implements CacheAdapterInterface +{ + /** + * @var array Mapping of method names to callables + */ + protected $callables; + + /** + * The callables array is an array mapping the actions of the cache adapter to callables. + * - contains: Callable that accepts an $id and $options argument + * - delete: Callable that accepts an $id and $options argument + * - fetch: Callable that accepts an $id and $options argument + * - save: Callable that accepts an $id, $data, $lifeTime, and $options argument + * + * @param array $callables array of action names to callable + * + * @throws \InvalidArgumentException if the callable is not callable + */ + public function __construct(array $callables) + { + // Validate each key to ensure it exists and is callable + foreach (array('contains', 'delete', 'fetch', 'save') as $key) { + if (!array_key_exists($key, $callables) || !is_callable($callables[$key])) { + throw new \InvalidArgumentException("callables must contain a callable {$key} key"); + } + } + + $this->callables = $callables; + } + + public function contains($id, array $options = null) + { + return call_user_func($this->callables['contains'], $id, $options); + } + + public function delete($id, array $options = null) + { + return call_user_func($this->callables['delete'], $id, $options); + } + + public function fetch($id, array $options = null) + { + return call_user_func($this->callables['fetch'], $id, $options); + } + + public function save($id, $data, $lifeTime = false, array $options = null) + { + return call_user_func($this->callables['save'], $id, $data, $lifeTime, $options); + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/DoctrineCacheAdapter.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/DoctrineCacheAdapter.php new file mode 100644 index 0000000..e1aaf9f --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/DoctrineCacheAdapter.php @@ -0,0 +1,41 @@ +<?php + +namespace Guzzle\Cache; + +use Doctrine\Common\Cache\Cache; + +/** + * Doctrine 2 cache adapter + * + * @link http://www.doctrine-project.org/ + */ +class DoctrineCacheAdapter extends AbstractCacheAdapter +{ + /** + * @param Cache $cache Doctrine cache object + */ + public function __construct(Cache $cache) + { + $this->cache = $cache; + } + + public function contains($id, array $options = null) + { + return $this->cache->contains($id); + } + + public function delete($id, array $options = null) + { + return $this->cache->delete($id); + } + + public function fetch($id, array $options = null) + { + return $this->cache->fetch($id); + } + + public function save($id, $data, $lifeTime = false, array $options = null) + { + return $this->cache->save($id, $data, $lifeTime !== false ? $lifeTime : 0); + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/NullCacheAdapter.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/NullCacheAdapter.php new file mode 100644 index 0000000..68bd4af --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/NullCacheAdapter.php @@ -0,0 +1,31 @@ +<?php + +namespace Guzzle\Cache; + +/** + * Null cache adapter + */ +class NullCacheAdapter extends AbstractCacheAdapter +{ + public function __construct() {} + + public function contains($id, array $options = null) + { + return false; + } + + public function delete($id, array $options = null) + { + return true; + } + + public function fetch($id, array $options = null) + { + return false; + } + + public function save($id, $data, $lifeTime = false, array $options = null) + { + return true; + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/Zf1CacheAdapter.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/Zf1CacheAdapter.php new file mode 100644 index 0000000..48f8e24 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/Zf1CacheAdapter.php @@ -0,0 +1,44 @@ +<?php + +namespace Guzzle\Cache; + +use Guzzle\Common\Version; + +/** + * Zend Framework 1 cache adapter + * + * @link http://framework.zend.com/manual/en/zend.cache.html + * @deprecated + * @codeCoverageIgnore + */ +class Zf1CacheAdapter extends AbstractCacheAdapter +{ + /** + * @param \Zend_Cache_Backend $cache Cache object to wrap + */ + public function __construct(\Zend_Cache_Backend $cache) + { + Version::warn(__CLASS__ . ' is deprecated. Upgrade to ZF2 or use PsrCacheAdapter'); + $this->cache = $cache; + } + + public function contains($id, array $options = null) + { + return $this->cache->test($id); + } + + public function delete($id, array $options = null) + { + return $this->cache->remove($id); + } + + public function fetch($id, array $options = null) + { + return $this->cache->load($id); + } + + public function save($id, $data, $lifeTime = false, array $options = null) + { + return $this->cache->save($data, $id, array(), $lifeTime); + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/Zf2CacheAdapter.php b/vendor/guzzle/guzzle/src/Guzzle/Cache/Zf2CacheAdapter.php new file mode 100644 index 0000000..1fc18a5 --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/Zf2CacheAdapter.php @@ -0,0 +1,41 @@ +<?php + +namespace Guzzle\Cache; + +use Zend\Cache\Storage\StorageInterface; + +/** + * Zend Framework 2 cache adapter + * + * @link http://packages.zendframework.com/docs/latest/manual/en/zend.cache.html + */ +class Zf2CacheAdapter extends AbstractCacheAdapter +{ + /** + * @param StorageInterface $cache Zend Framework 2 cache adapter + */ + public function __construct(StorageInterface $cache) + { + $this->cache = $cache; + } + + public function contains($id, array $options = null) + { + return $this->cache->hasItem($id); + } + + public function delete($id, array $options = null) + { + return $this->cache->removeItem($id); + } + + public function fetch($id, array $options = null) + { + return $this->cache->getItem($id); + } + + public function save($id, $data, $lifeTime = false, array $options = null) + { + return $this->cache->setItem($id, $data); + } +} diff --git a/vendor/guzzle/guzzle/src/Guzzle/Cache/composer.json b/vendor/guzzle/guzzle/src/Guzzle/Cache/composer.json new file mode 100644 index 0000000..a5d999b --- /dev/null +++ b/vendor/guzzle/guzzle/src/Guzzle/Cache/composer.json @@ -0,0 +1,27 @@ +{ + "name": "guzzle/cache", + "description": "Guzzle cache adapter component", + "homepage": "http://guzzlephp.org/", + "keywords": ["cache", "adapter", "zf", "doctrine", "guzzle"], + "license": "MIT", + "authors": [ + { + "name": "Michael Dowling", + "email": "mtdowling@gmail.com", + "homepage": "https://github.com/mtdowling" + } + ], + "require": { + "php": ">=5.3.2", + "guzzle/common": "self.version" + }, + "autoload": { + "psr-0": { "Guzzle\\Cache": "" } + }, + "target-dir": "Guzzle/Cache", + "extra": { + "branch-alias": { + "dev-master": "3.7-dev" + } + } +} |