Initial import.

vendor/guzzle/cache/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;
+    }
+}

vendor/guzzle/cache/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);
+        }
+    }
+}

vendor/guzzle/cache/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);
+}

vendor/guzzle/cache/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);
+    }
+}

vendor/guzzle/cache/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);
+    }
+}

vendor/guzzle/cache/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;
+    }
+}

vendor/guzzle/cache/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);
+    }
+}

vendor/guzzle/cache/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);
+    }
+}

vendor/guzzle/cache/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"
+        }
+    }
+}