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 {
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])) {
$config[$required] = str_replace('.', '\\', $config[$required]);
if (!class_exists($config[$required])) {
throw new InvalidArgumentException("{$config[$required]} is not a valid class for {$required}");
}
}
}
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);
}
}
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'];
}
public function __construct($username, $password, $scheme = CURLAUTH_BASIC)
{
Version::warn(__CLASS__ . " is deprecated. Use \$client->getConfig()->setPath('request.options/auth', array('user', 'pass', 'Basic|Digest');");
$this->username = $username;
$this->password = $password;
$this->scheme = $scheme;
}
protected function setUp()
{
if (!version_compare(Version::VERSION, '3.6', '>=')) {
$this->markTestSkipped('the emitWarning property was added in Guzzle 3.6');
}
$this->container = new ContainerBuilder();
$this->extension = new MisdGuzzleExtension();
// reset the emit warnings options before each test
Version::$emitWarnings = false;
}
public function testAddsDigestAuthentication()
{
Version::$emitWarnings = false;
$plugin = new CurlAuthPlugin('julian', 'test', CURLAUTH_DIGEST);
$client = new Client('http://www.test.com/');
$client->getEventDispatcher()->addSubscriber($plugin);
$request = $client->get('/');
$this->assertEquals('julian', $request->getUsername());
$this->assertEquals('test', $request->getPassword());
$this->assertEquals('julian:test', $request->getCurlOptions()->get(CURLOPT_USERPWD));
$this->assertEquals(CURLAUTH_DIGEST, $request->getCurlOptions()->get(CURLOPT_HTTPAUTH));
Version::$emitWarnings = true;
}
public function parseUrl($url)
{
Version::warn(__CLASS__ . ' is deprecated. Just use parse_url()');
static $defaults = array('scheme' => null, 'host' => null, 'path' => null, 'port' => null, 'query' => null, 'user' => null, 'pass' => null, 'fragment' => null);
$parts = parse_url($url);
if ($this->utf8 && isset($parts['query'])) {
$queryPos = strpos($url, '?');
if (isset($parts['fragment'])) {
$parts['query'] = substr($url, $queryPos + 1, strpos($url, '#') - $queryPos - 1);
} else {
$parts['query'] = substr($url, $queryPos + 1);
}
}
return $parts + $defaults;
}
public function testCanGetScannedCount()
{
$emitWarnings = Version::$emitWarnings;
Version::$emitWarnings = false;
$command = $this->getMock('Guzzle\\Service\\Command\\CommandInterface');
$iterator = new ScanIterator($command, array('result_key' => 'Items'));
$model = new Model(array('Items' => array(1, 2, 3), 'ScannedCount' => 4));
$class = new \ReflectionObject($iterator);
$method = $class->getMethod('handleResults');
$method->setAccessible(true);
$items = $method->invoke($iterator, $model);
$this->assertEquals(4, $iterator->getScannedCount());
$this->assertCount(3, $items);
Version::$emitWarnings = $emitWarnings;
}
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$loader->load('plugin.xml');
$loader->load('log.xml');
if ($config['serializer']) {
$loader->load('serializer.xml');
}
if (interface_exists('Sensio\\Bundle\\FrameworkExtraBundle\\Request\\ParamConverter\\ParamConverterInterface')) {
// choose a ParamConverterInterface implementation that is compatible
// with the version of SensioFrameworkExtraBundle being used
$parameter = new \ReflectionParameter(array('Sensio\\Bundle\\FrameworkExtraBundle\\Request\\ParamConverter\\ParamConverterInterface', 'supports'), 'configuration');
if ('Sensio\\Bundle\\FrameworkExtraBundle\\Configuration\\ParamConverter' == $parameter->getClass()->getName()) {
$container->setParameter('misd_guzzle.param_converter.class', 'Misd\\GuzzleBundle\\Request\\ParamConverter\\GuzzleParamConverter3x');
} else {
$container->setParameter('misd_guzzle.param_converter.class', 'Misd\\GuzzleBundle\\Request\\ParamConverter\\GuzzleParamConverter2x');
}
$loader->load('param_converter.xml');
}
if ($config['service_builder']['enabled']) {
$loader->load('service_builder.xml');
$container->setParameter('guzzle.service_builder.class', $config['service_builder']['class']);
$container->setParameter('guzzle.service_builder.configuration_file', $config['service_builder']['configuration_file']);
}
if ($config['filesystem_cache']['enabled']) {
$loader->load('cache.xml');
$container->setParameter('misd_guzzle.cache.filesystem.path', $config['filesystem_cache']['path']);
}
$logFormat = $config['log']['format'];
if (in_array($logFormat, array('default', 'debug', 'short'))) {
$logFormat = constant(sprintf('Guzzle\\Log\\MessageFormatter::%s_FORMAT', strtoupper($logFormat)));
}
$container->setParameter('misd_guzzle.log.format', $logFormat);
$container->setParameter('misd_guzzle.log.enabled', $config['log']['enabled']);
if (version_compare(Version::VERSION, '3.6', '>=') && $container->hasParameter('kernel.debug')) {
Version::$emitWarnings = $container->getParameter('kernel.debug');
}
}
public static function calculateMd5(EntityBodyInterface $body, $rawOutput = false, $base64Encode = false)
{
Version::warn(__CLASS__ . ' is deprecated. Use getContentMd5()');
return $body->getContentMd5($rawOutput, $base64Encode);
}
/**
* @deprecated
* @codeCoverageIgnore
*/
public function removeCacheControlDirective($directive)
{
Version::warn(__METHOD__ . ' is deprecated. Use $message->getHeader(\'Cache-Control\')->removeDirective()');
if ($header = $this->getHeader('Cache-Control')) {
$header->removeDirective($directive);
}
return $this;
}
/**
* Get the total number of scanned items
*
* @return int
*/
public function getScannedCount()
{
Version::warn('This method is deprecated and will be removed in a future version of the SDK. Getting the ' . 'scanned count is possible using event listeners.');
return $this->scannedCount;
}
/**
* @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 __construct(\Zend_Log $logObject)
{
$this->log = $logObject;
Version::warn(__CLASS__ . ' is deprecated');
}
/**
* @param ResourceIteratorInterface $iterator Resource iterator to apply a callback to
* @param array|callable $callback Callback method accepting the resource iterator
* and an array of the iterator's current resources
*/
public function __construct(ResourceIteratorInterface $iterator, $callback)
{
$this->iterator = $iterator;
$this->callback = $callback;
Version::warn(__CLASS__ . ' is deprecated');
}
/**
* @deprecated
* @codeCoverageIgnore
*/
public function getRequest()
{
Version::warn(__METHOD__ . ' is deprecated');
return null;
}
<?php
namespace Guzzle\Plugin\Cache;
use Guzzle\Http\Message\RequestInterface;
\Guzzle\Common\Version::warn('Guzzle\\Plugin\\Cache\\DefaultCacheKeyProvider is no longer used');
class DefaultCacheKeyProvider implements CacheKeyProviderInterface
{
public function getCacheKey(RequestInterface $request)
{
$key = $request->getParams()->get(self::CACHE_KEY);
if (!$key) {
$cloned = clone $request;
$cloned->removeHeader('Cache-Control');
foreach (explode(';', $request->getParams()->get(self::CACHE_KEY_FILTER)) as $part) {
$pieces = array_map('trim', explode('=', $part));
if (isset($pieces[1])) {
foreach (array_map('trim', explode(',', $pieces[1])) as $remove) {
if ($pieces[0] == 'header') {
$cloned->removeHeader($remove);
} elseif ($pieces[0] == 'query') {
$cloned->getQuery()->remove($remove);
}
}
}
}
$raw = (string) $cloned;
$key = 'GZ' . md5($raw);
$request->getParams()->set(self::CACHE_KEY, $key)->set(self::CACHE_KEY_RAW, $raw);
}
return $key;
/**
* @deprecated
* @codeCoverageIgnore
*/
public function raw()
{
Version::warn(__METHOD__ . ' is deprecated. Use toArray()');
return $this->toArray();
}
/**
* @deprecated Use the history plugin
* @codeCoverageIgnore
*/
public function isRedirect()
{
Version::warn(__METHOD__ . ' is deprecated. Use the HistoryPlugin to track this.');
return $this->isRedirect;
}
/**
* @deprecated
* @codeCoverageIgnore
*/
public function enableMagicMethods($isEnabled)
{
Version::warn(__METHOD__ . ' is deprecated');
}
public function testCanSilenceWarnings()
{
Version::$emitWarnings = false;
Version::warn('testing!');
Version::$emitWarnings = true;
}
<?php
namespace Guzzle\Plugin\Cache;
\Guzzle\Common\Version::warn('Guzzle\\Plugin\\Cache\\CacheKeyProviderInterface is no longer used');
interface CacheKeyProviderInterface
{
}
/**
* @deprecated
*/
public function setDefaultHeaders($headers)
{
Version::warn(__METHOD__ . ' is deprecated. Use the request.options array to specify default request options');
if ($headers instanceof Collection) {
$this->defaultHeaders = $headers;
} elseif (is_array($headers)) {
$this->defaultHeaders = new Collection($headers);
} else {
throw new InvalidArgumentException('Headers must be an array or Collection');
}
return $this;
}
public function testAllowsDefaultHeaders()
{
Version::$emitWarnings = false;
$default = array('X-Test' => 'Hi!');
$other = array('X-Other' => 'Foo');
$client = new Client();
$client->setDefaultHeaders($default);
$this->assertEquals($default, $client->getDefaultHeaders()->getAll());
$client->setDefaultHeaders(new Collection($default));
$this->assertEquals($default, $client->getDefaultHeaders()->getAll());
$request = $client->createRequest('GET', null, $other);
$this->assertEquals('Hi!', $request->getHeader('X-Test'));
$this->assertEquals('Foo', $request->getHeader('X-Other'));
$request = $client->createRequest('GET', null, new Collection($other));
$this->assertEquals('Hi!', $request->getHeader('X-Test'));
$this->assertEquals('Foo', $request->getHeader('X-Other'));
$request = $client->createRequest('GET');
$this->assertEquals('Hi!', $request->getHeader('X-Test'));
Version::$emitWarnings = true;
}
public function getCurlString()
{
Version::warn(__METHOD__ . ' is deprecated. Use getCurlValue()');
return $this->getCurlValue();
}
/**
* Inject configuration settings into an input string
*
* @param string $input Input to inject
*
* @return string
* @deprecated
*/
public function inject($input)
{
Version::warn(__METHOD__ . ' is deprecated');
$replace = array();
foreach ($this->data as $key => $val) {
$replace['{' . $key . '}'] = $val;
}
return strtr($input, $replace);
}