first commit

modules/ps_facebook/vendor/symfony/cache/Simple/AbstractCache.php

@@ -0,0 +1,190 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Psr\Log\LoggerAwareInterface;
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\CacheItem;
+use Symfony\Component\Cache\Exception\InvalidArgumentException;
+use Symfony\Component\Cache\ResettableInterface;
+use Symfony\Component\Cache\Traits\AbstractTrait;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+abstract class AbstractCache implements CacheInterface, LoggerAwareInterface, ResettableInterface
+{
+    /**
+     * @internal
+     */
+    const NS_SEPARATOR = ':';
+
+    use AbstractTrait {
+        deleteItems as private;
+        AbstractTrait::deleteItem as delete;
+        AbstractTrait::hasItem as has;
+    }
+
+    private $defaultLifetime;
+
+    /**
+     * @param string $namespace
+     * @param int    $defaultLifetime
+     */
+    protected function __construct($namespace = '', $defaultLifetime = 0)
+    {
+        $this->defaultLifetime = max(0, (int) $defaultLifetime);
+        $this->namespace = '' === $namespace ? '' : CacheItem::validateKey($namespace).':';
+        if (null !== $this->maxIdLength && \strlen($namespace) > $this->maxIdLength - 24) {
+            throw new InvalidArgumentException(sprintf('Namespace must be %d chars max, %d given ("%s").', $this->maxIdLength - 24, \strlen($namespace), $namespace));
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        $id = $this->getId($key);
+
+        try {
+            foreach ($this->doFetch([$id]) as $value) {
+                return $value;
+            }
+        } catch (\Exception $e) {
+            CacheItem::log($this->logger, 'Failed to fetch key "{key}"', ['key' => $key, 'exception' => $e]);
+        }
+
+        return $default;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        CacheItem::validateKey($key);
+
+        return $this->setMultiple([$key => $value], $ttl);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+        $ids = [];
+
+        foreach ($keys as $key) {
+            $ids[] = $this->getId($key);
+        }
+        try {
+            $values = $this->doFetch($ids);
+        } catch (\Exception $e) {
+            CacheItem::log($this->logger, 'Failed to fetch requested values', ['keys' => $keys, 'exception' => $e]);
+            $values = [];
+        }
+        $ids = array_combine($ids, $keys);
+
+        return $this->generateValues($values, $ids, $default);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        if (!\is_array($values) && !$values instanceof \Traversable) {
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
+        }
+        $valuesById = [];
+
+        foreach ($values as $key => $value) {
+            if (\is_int($key)) {
+                $key = (string) $key;
+            }
+            $valuesById[$this->getId($key)] = $value;
+        }
+        if (false === $ttl = $this->normalizeTtl($ttl)) {
+            return $this->doDelete(array_keys($valuesById));
+        }
+
+        try {
+            $e = $this->doSave($valuesById, $ttl);
+        } catch (\Exception $e) {
+        }
+        if (true === $e || [] === $e) {
+            return true;
+        }
+        $keys = [];
+        foreach (\is_array($e) ? $e : array_keys($valuesById) as $id) {
+            $keys[] = substr($id, \strlen($this->namespace));
+        }
+        CacheItem::log($this->logger, 'Failed to save values', ['keys' => $keys, 'exception' => $e instanceof \Exception ? $e : null]);
+
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+
+        return $this->deleteItems($keys);
+    }
+
+    private function normalizeTtl($ttl)
+    {
+        if (null === $ttl) {
+            return $this->defaultLifetime;
+        }
+        if ($ttl instanceof \DateInterval) {
+            $ttl = (int) \DateTime::createFromFormat('U', 0)->add($ttl)->format('U');
+        }
+        if (\is_int($ttl)) {
+            return 0 < $ttl ? $ttl : false;
+        }
+
+        throw new InvalidArgumentException(sprintf('Expiration date must be an integer, a DateInterval or null, "%s" given.', \is_object($ttl) ? \get_class($ttl) : \gettype($ttl)));
+    }
+
+    private function generateValues($values, &$keys, $default)
+    {
+        try {
+            foreach ($values as $id => $value) {
+                if (!isset($keys[$id])) {
+                    $id = key($keys);
+                }
+                $key = $keys[$id];
+                unset($keys[$id]);
+                yield $key => $value;
+            }
+        } catch (\Exception $e) {
+            CacheItem::log($this->logger, 'Failed to fetch requested values', ['keys' => array_values($keys), 'exception' => $e]);
+        }
+
+        foreach ($keys as $key) {
+            yield $key => $default;
+        }
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/ApcuCache.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Symfony\Component\Cache\Traits\ApcuTrait;
+
+class ApcuCache extends AbstractCache
+{
+    use ApcuTrait;
+
+    /**
+     * @param string      $namespace
+     * @param int         $defaultLifetime
+     * @param string|null $version
+     */
+    public function __construct($namespace = '', $defaultLifetime = 0, $version = null)
+    {
+        $this->init($namespace, $defaultLifetime, $version);
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/ArrayCache.php

@@ -0,0 +1,148 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Psr\Log\LoggerAwareInterface;
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\CacheItem;
+use Symfony\Component\Cache\Exception\InvalidArgumentException;
+use Symfony\Component\Cache\ResettableInterface;
+use Symfony\Component\Cache\Traits\ArrayTrait;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ArrayCache implements CacheInterface, LoggerAwareInterface, ResettableInterface
+{
+    use ArrayTrait {
+        ArrayTrait::deleteItem as delete;
+        ArrayTrait::hasItem as has;
+    }
+
+    private $defaultLifetime;
+
+    /**
+     * @param int  $defaultLifetime
+     * @param bool $storeSerialized Disabling serialization can lead to cache corruptions when storing mutable values but increases performance otherwise
+     */
+    public function __construct($defaultLifetime = 0, $storeSerialized = true)
+    {
+        $this->defaultLifetime = (int) $defaultLifetime;
+        $this->storeSerialized = $storeSerialized;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        foreach ($this->getMultiple([$key], $default) as $v) {
+            return $v;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+        foreach ($keys as $key) {
+            CacheItem::validateKey($key);
+        }
+
+        return $this->generateItems($keys, time(), function ($k, $v, $hit) use ($default) { return $hit ? $v : $default; });
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        if (!\is_array($keys) && !$keys instanceof \Traversable) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+        foreach ($keys as $key) {
+            $this->delete($key);
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        CacheItem::validateKey($key);
+
+        return $this->setMultiple([$key => $value], $ttl);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        if (!\is_array($values) && !$values instanceof \Traversable) {
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
+        }
+        $valuesArray = [];
+
+        foreach ($values as $key => $value) {
+            \is_int($key) || CacheItem::validateKey($key);
+            $valuesArray[$key] = $value;
+        }
+        if (false === $ttl = $this->normalizeTtl($ttl)) {
+            return $this->deleteMultiple(array_keys($valuesArray));
+        }
+        if ($this->storeSerialized) {
+            foreach ($valuesArray as $key => $value) {
+                try {
+                    $valuesArray[$key] = serialize($value);
+                } catch (\Exception $e) {
+                    $type = \is_object($value) ? \get_class($value) : \gettype($value);
+                    CacheItem::log($this->logger, 'Failed to save key "{key}" ({type})', ['key' => $key, 'type' => $type, 'exception' => $e]);
+
+                    return false;
+                }
+            }
+        }
+        $expiry = 0 < $ttl ? time() + $ttl : \PHP_INT_MAX;
+
+        foreach ($valuesArray as $key => $value) {
+            $this->values[$key] = $value;
+            $this->expiries[$key] = $expiry;
+        }
+
+        return true;
+    }
+
+    private function normalizeTtl($ttl)
+    {
+        if (null === $ttl) {
+            return $this->defaultLifetime;
+        }
+        if ($ttl instanceof \DateInterval) {
+            $ttl = (int) \DateTime::createFromFormat('U', 0)->add($ttl)->format('U');
+        }
+        if (\is_int($ttl)) {
+            return 0 < $ttl ? $ttl : false;
+        }
+
+        throw new InvalidArgumentException(sprintf('Expiration date must be an integer, a DateInterval or null, "%s" given.', \is_object($ttl) ? \get_class($ttl) : \gettype($ttl)));
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/ChainCache.php

@@ -0,0 +1,252 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\Exception\InvalidArgumentException;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\ResettableInterface;
+
+/**
+ * Chains several caches together.
+ *
+ * Cached items are fetched from the first cache having them in its data store.
+ * They are saved and deleted in all caches at once.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ChainCache implements CacheInterface, PruneableInterface, ResettableInterface
+{
+    private $miss;
+    private $caches = [];
+    private $defaultLifetime;
+    private $cacheCount;
+
+    /**
+     * @param CacheInterface[] $caches          The ordered list of caches used to fetch cached items
+     * @param int              $defaultLifetime The lifetime of items propagated from lower caches to upper ones
+     */
+    public function __construct(array $caches, $defaultLifetime = 0)
+    {
+        if (!$caches) {
+            throw new InvalidArgumentException('At least one cache must be specified.');
+        }
+
+        foreach ($caches as $cache) {
+            if (!$cache instanceof CacheInterface) {
+                throw new InvalidArgumentException(sprintf('The class "%s" does not implement the "%s" interface.', \get_class($cache), CacheInterface::class));
+            }
+        }
+
+        $this->miss = new \stdClass();
+        $this->caches = array_values($caches);
+        $this->cacheCount = \count($this->caches);
+        $this->defaultLifetime = 0 < $defaultLifetime ? (int) $defaultLifetime : null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        $miss = null !== $default && \is_object($default) ? $default : $this->miss;
+
+        foreach ($this->caches as $i => $cache) {
+            $value = $cache->get($key, $miss);
+
+            if ($miss !== $value) {
+                while (0 <= --$i) {
+                    $this->caches[$i]->set($key, $value, $this->defaultLifetime);
+                }
+
+                return $value;
+            }
+        }
+
+        return $default;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        $miss = null !== $default && \is_object($default) ? $default : $this->miss;
+
+        return $this->generateItems($this->caches[0]->getMultiple($keys, $miss), 0, $miss, $default);
+    }
+
+    private function generateItems($values, $cacheIndex, $miss, $default)
+    {
+        $missing = [];
+        $nextCacheIndex = $cacheIndex + 1;
+        $nextCache = isset($this->caches[$nextCacheIndex]) ? $this->caches[$nextCacheIndex] : null;
+
+        foreach ($values as $k => $value) {
+            if ($miss !== $value) {
+                yield $k => $value;
+            } elseif (!$nextCache) {
+                yield $k => $default;
+            } else {
+                $missing[] = $k;
+            }
+        }
+
+        if ($missing) {
+            $cache = $this->caches[$cacheIndex];
+            $values = $this->generateItems($nextCache->getMultiple($missing, $miss), $nextCacheIndex, $miss, $default);
+
+            foreach ($values as $k => $value) {
+                if ($miss !== $value) {
+                    $cache->set($k, $value, $this->defaultLifetime);
+                    yield $k => $value;
+                } else {
+                    yield $k => $default;
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        foreach ($this->caches as $cache) {
+            if ($cache->has($key)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        $cleared = true;
+        $i = $this->cacheCount;
+
+        while ($i--) {
+            $cleared = $this->caches[$i]->clear() && $cleared;
+        }
+
+        return $cleared;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($key)
+    {
+        $deleted = true;
+        $i = $this->cacheCount;
+
+        while ($i--) {
+            $deleted = $this->caches[$i]->delete($key) && $deleted;
+        }
+
+        return $deleted;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        }
+        $deleted = true;
+        $i = $this->cacheCount;
+
+        while ($i--) {
+            $deleted = $this->caches[$i]->deleteMultiple($keys) && $deleted;
+        }
+
+        return $deleted;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        $saved = true;
+        $i = $this->cacheCount;
+
+        while ($i--) {
+            $saved = $this->caches[$i]->set($key, $value, $ttl) && $saved;
+        }
+
+        return $saved;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        if ($values instanceof \Traversable) {
+            $valuesIterator = $values;
+            $values = function () use ($valuesIterator, &$values) {
+                $generatedValues = [];
+
+                foreach ($valuesIterator as $key => $value) {
+                    yield $key => $value;
+                    $generatedValues[$key] = $value;
+                }
+
+                $values = $generatedValues;
+            };
+            $values = $values();
+        }
+        $saved = true;
+        $i = $this->cacheCount;
+
+        while ($i--) {
+            $saved = $this->caches[$i]->setMultiple($values, $ttl) && $saved;
+        }
+
+        return $saved;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prune()
+    {
+        $pruned = true;
+
+        foreach ($this->caches as $cache) {
+            if ($cache instanceof PruneableInterface) {
+                $pruned = $cache->prune() && $pruned;
+            }
+        }
+
+        return $pruned;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function reset()
+    {
+        foreach ($this->caches as $cache) {
+            if ($cache instanceof ResettableInterface) {
+                $cache->reset();
+            }
+        }
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/DoctrineCache.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Doctrine\Common\Cache\CacheProvider;
+use Symfony\Component\Cache\Traits\DoctrineTrait;
+
+class DoctrineCache extends AbstractCache
+{
+    use DoctrineTrait;
+
+    /**
+     * @param string $namespace
+     * @param int    $defaultLifetime
+     */
+    public function __construct(CacheProvider $provider, $namespace = '', $defaultLifetime = 0)
+    {
+        parent::__construct('', $defaultLifetime);
+        $this->provider = $provider;
+        $provider->setNamespace($namespace);
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/FilesystemCache.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\Traits\FilesystemTrait;
+
+class FilesystemCache extends AbstractCache implements PruneableInterface
+{
+    use FilesystemTrait;
+
+    /**
+     * @param string      $namespace
+     * @param int         $defaultLifetime
+     * @param string|null $directory
+     */
+    public function __construct($namespace = '', $defaultLifetime = 0, $directory = null)
+    {
+        parent::__construct('', $defaultLifetime);
+        $this->init($namespace, $directory);
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/MemcachedCache.php

@@ -0,0 +1,30 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Symfony\Component\Cache\Traits\MemcachedTrait;
+
+class MemcachedCache extends AbstractCache
+{
+    use MemcachedTrait;
+
+    protected $maxIdLength = 250;
+
+    /**
+     * @param string $namespace
+     * @param int    $defaultLifetime
+     */
+    public function __construct(\Memcached $client, $namespace = '', $defaultLifetime = 0)
+    {
+        $this->init($client, $namespace, $defaultLifetime);
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/NullCache.php

@@ -0,0 +1,86 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Psr\SimpleCache\CacheInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class NullCache implements CacheInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        return $default;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        foreach ($keys as $key) {
+            yield $key => $default;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($key)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        return false;
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/PdoCache.php

@@ -0,0 +1,51 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\Traits\PdoTrait;
+
+class PdoCache extends AbstractCache implements PruneableInterface
+{
+    use PdoTrait;
+
+    protected $maxIdLength = 255;
+
+    /**
+     * You can either pass an existing database connection as PDO instance or
+     * a Doctrine DBAL Connection or a DSN string that will be used to
+     * lazy-connect to the database when the cache is actually used.
+     *
+     * List of available options:
+     *  * db_table: The name of the table [default: cache_items]
+     *  * db_id_col: The column where to store the cache id [default: item_id]
+     *  * db_data_col: The column where to store the cache data [default: item_data]
+     *  * db_lifetime_col: The column where to store the lifetime [default: item_lifetime]
+     *  * db_time_col: The column where to store the timestamp [default: item_time]
+     *  * db_username: The username when lazy-connect [default: '']
+     *  * db_password: The password when lazy-connect [default: '']
+     *  * db_connection_options: An array of driver-specific connection options [default: []]
+     *
+     * @param \PDO|Connection|string $connOrDsn       A \PDO or Connection instance or DSN string or null
+     * @param string                 $namespace
+     * @param int                    $defaultLifetime
+     * @param array                  $options         An associative array of options
+     *
+     * @throws InvalidArgumentException When first argument is not PDO nor Connection nor string
+     * @throws InvalidArgumentException When PDO error mode is not PDO::ERRMODE_EXCEPTION
+     * @throws InvalidArgumentException When namespace contains invalid characters
+     */
+    public function __construct($connOrDsn, $namespace = '', $defaultLifetime = 0, array $options = [])
+    {
+        $this->init($connOrDsn, $namespace, $defaultLifetime, $options);
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/PhpArrayCache.php

@@ -0,0 +1,259 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\Exception\InvalidArgumentException;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\ResettableInterface;
+use Symfony\Component\Cache\Traits\PhpArrayTrait;
+
+/**
+ * Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0.
+ * Warmed up items are read-only and run-time discovered items are cached using a fallback adapter.
+ *
+ * @author Titouan Galopin <galopintitouan@gmail.com>
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class PhpArrayCache implements CacheInterface, PruneableInterface, ResettableInterface
+{
+    use PhpArrayTrait;
+
+    /**
+     * @param string         $file         The PHP file were values are cached
+     * @param CacheInterface $fallbackPool A pool to fallback on when an item is not hit
+     */
+    public function __construct($file, CacheInterface $fallbackPool)
+    {
+        $this->file = $file;
+        $this->pool = $fallbackPool;
+        $this->zendDetectUnicode = filter_var(ini_get('zend.detect_unicode'), \FILTER_VALIDATE_BOOLEAN);
+    }
+
+    /**
+     * This adapter should only be used on PHP 7.0+ to take advantage of how PHP
+     * stores arrays in its latest versions. This factory method decorates the given
+     * fallback pool with this adapter only if the current PHP version is supported.
+     *
+     * @param string         $file         The PHP file were values are cached
+     * @param CacheInterface $fallbackPool A pool to fallback on when an item is not hit
+     *
+     * @return CacheInterface
+     */
+    public static function create($file, CacheInterface $fallbackPool)
+    {
+        if (\PHP_VERSION_ID >= 70000) {
+            return new static($file, $fallbackPool);
+        }
+
+        return $fallbackPool;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        if (!\is_string($key)) {
+            throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
+        }
+        if (null === $this->values) {
+            $this->initialize();
+        }
+        if (!isset($this->values[$key])) {
+            return $this->pool->get($key, $default);
+        }
+
+        $value = $this->values[$key];
+
+        if ('N;' === $value) {
+            $value = null;
+        } elseif (\is_string($value) && isset($value[2]) && ':' === $value[1]) {
+            try {
+                $e = null;
+                $value = unserialize($value);
+            } catch (\Error $e) {
+            } catch (\Exception $e) {
+            }
+            if (null !== $e) {
+                return $default;
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+        foreach ($keys as $key) {
+            if (!\is_string($key)) {
+                throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
+            }
+        }
+        if (null === $this->values) {
+            $this->initialize();
+        }
+
+        return $this->generateItems($keys, $default);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        if (!\is_string($key)) {
+            throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
+        }
+        if (null === $this->values) {
+            $this->initialize();
+        }
+
+        return isset($this->values[$key]) || $this->pool->has($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($key)
+    {
+        if (!\is_string($key)) {
+            throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
+        }
+        if (null === $this->values) {
+            $this->initialize();
+        }
+
+        return !isset($this->values[$key]) && $this->pool->delete($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        if (!\is_array($keys) && !$keys instanceof \Traversable) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+
+        $deleted = true;
+        $fallbackKeys = [];
+
+        foreach ($keys as $key) {
+            if (!\is_string($key)) {
+                throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
+            }
+
+            if (isset($this->values[$key])) {
+                $deleted = false;
+            } else {
+                $fallbackKeys[] = $key;
+            }
+        }
+        if (null === $this->values) {
+            $this->initialize();
+        }
+
+        if ($fallbackKeys) {
+            $deleted = $this->pool->deleteMultiple($fallbackKeys) && $deleted;
+        }
+
+        return $deleted;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        if (!\is_string($key)) {
+            throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
+        }
+        if (null === $this->values) {
+            $this->initialize();
+        }
+
+        return !isset($this->values[$key]) && $this->pool->set($key, $value, $ttl);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        if (!\is_array($values) && !$values instanceof \Traversable) {
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
+        }
+
+        $saved = true;
+        $fallbackValues = [];
+
+        foreach ($values as $key => $value) {
+            if (!\is_string($key) && !\is_int($key)) {
+                throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
+            }
+
+            if (isset($this->values[$key])) {
+                $saved = false;
+            } else {
+                $fallbackValues[$key] = $value;
+            }
+        }
+
+        if ($fallbackValues) {
+            $saved = $this->pool->setMultiple($fallbackValues, $ttl) && $saved;
+        }
+
+        return $saved;
+    }
+
+    private function generateItems(array $keys, $default)
+    {
+        $fallbackKeys = [];
+
+        foreach ($keys as $key) {
+            if (isset($this->values[$key])) {
+                $value = $this->values[$key];
+
+                if ('N;' === $value) {
+                    yield $key => null;
+                } elseif (\is_string($value) && isset($value[2]) && ':' === $value[1]) {
+                    try {
+                        yield $key => unserialize($value);
+                    } catch (\Error $e) {
+                        yield $key => $default;
+                    } catch (\Exception $e) {
+                        yield $key => $default;
+                    }
+                } else {
+                    yield $key => $value;
+                }
+            } else {
+                $fallbackKeys[] = $key;
+            }
+        }
+
+        if ($fallbackKeys) {
+            foreach ($this->pool->getMultiple($fallbackKeys, $default) as $key => $item) {
+                yield $key => $item;
+            }
+        }
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/PhpFilesCache.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Symfony\Component\Cache\Exception\CacheException;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\Traits\PhpFilesTrait;
+
+class PhpFilesCache extends AbstractCache implements PruneableInterface
+{
+    use PhpFilesTrait;
+
+    /**
+     * @param string      $namespace
+     * @param int         $defaultLifetime
+     * @param string|null $directory
+     *
+     * @throws CacheException if OPcache is not enabled
+     */
+    public function __construct($namespace = '', $defaultLifetime = 0, $directory = null)
+    {
+        if (!static::isSupported()) {
+            throw new CacheException('OPcache is not enabled.');
+        }
+        parent::__construct('', $defaultLifetime);
+        $this->init($namespace, $directory);
+
+        $e = new \Exception();
+        $this->includeHandler = function () use ($e) { throw $e; };
+        $this->zendDetectUnicode = filter_var(ini_get('zend.detect_unicode'), \FILTER_VALIDATE_BOOLEAN);
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/Psr6Cache.php

@@ -0,0 +1,241 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Psr\Cache\CacheException as Psr6CacheException;
+use Psr\Cache\CacheItemPoolInterface;
+use Psr\SimpleCache\CacheException as SimpleCacheException;
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\Adapter\AdapterInterface;
+use Symfony\Component\Cache\CacheItem;
+use Symfony\Component\Cache\Exception\InvalidArgumentException;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\ResettableInterface;
+use Symfony\Component\Cache\Traits\ProxyTrait;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class Psr6Cache implements CacheInterface, PruneableInterface, ResettableInterface
+{
+    use ProxyTrait;
+
+    private $createCacheItem;
+    private $cacheItemPrototype;
+
+    public function __construct(CacheItemPoolInterface $pool)
+    {
+        $this->pool = $pool;
+
+        if (!$pool instanceof AdapterInterface) {
+            return;
+        }
+        $cacheItemPrototype = &$this->cacheItemPrototype;
+        $createCacheItem = \Closure::bind(
+            static function ($key, $value, $allowInt = false) use (&$cacheItemPrototype) {
+                $item = clone $cacheItemPrototype;
+                $item->key = $allowInt && \is_int($key) ? (string) $key : CacheItem::validateKey($key);
+                $item->value = $value;
+                $item->isHit = false;
+
+                return $item;
+            },
+            null,
+            CacheItem::class
+        );
+        $this->createCacheItem = function ($key, $value, $allowInt = false) use ($createCacheItem) {
+            if (null === $this->cacheItemPrototype) {
+                $this->get($allowInt && \is_int($key) ? (string) $key : $key);
+            }
+            $this->createCacheItem = $createCacheItem;
+
+            return $createCacheItem($key, $value, $allowInt);
+        };
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        try {
+            $item = $this->pool->getItem($key);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        if (null === $this->cacheItemPrototype) {
+            $this->cacheItemPrototype = clone $item;
+            $this->cacheItemPrototype->set(null);
+        }
+
+        return $item->isHit() ? $item->get() : $default;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        try {
+            if (null !== $f = $this->createCacheItem) {
+                $item = $f($key, $value);
+            } else {
+                $item = $this->pool->getItem($key)->set($value);
+            }
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        if (null !== $ttl) {
+            $item->expiresAfter($ttl);
+        }
+
+        return $this->pool->save($item);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($key)
+    {
+        try {
+            return $this->pool->deleteItem($key);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        return $this->pool->clear();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+
+        try {
+            $items = $this->pool->getItems($keys);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        $values = [];
+
+        foreach ($items as $key => $item) {
+            $values[$key] = $item->isHit() ? $item->get() : $default;
+        }
+
+        return $values;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        $valuesIsArray = \is_array($values);
+        if (!$valuesIsArray && !$values instanceof \Traversable) {
+            throw new InvalidArgumentException(sprintf('Cache values must be array or Traversable, "%s" given.', \is_object($values) ? \get_class($values) : \gettype($values)));
+        }
+        $items = [];
+
+        try {
+            if (null !== $f = $this->createCacheItem) {
+                $valuesIsArray = false;
+                foreach ($values as $key => $value) {
+                    $items[$key] = $f($key, $value, true);
+                }
+            } elseif ($valuesIsArray) {
+                $items = [];
+                foreach ($values as $key => $value) {
+                    $items[] = (string) $key;
+                }
+                $items = $this->pool->getItems($items);
+            } else {
+                foreach ($values as $key => $value) {
+                    if (\is_int($key)) {
+                        $key = (string) $key;
+                    }
+                    $items[$key] = $this->pool->getItem($key)->set($value);
+                }
+            }
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+        $ok = true;
+
+        foreach ($items as $key => $item) {
+            if ($valuesIsArray) {
+                $item->set($values[$key]);
+            }
+            if (null !== $ttl) {
+                $item->expiresAfter($ttl);
+            }
+            $ok = $this->pool->saveDeferred($item) && $ok;
+        }
+
+        return $this->pool->commit() && $ok;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        if ($keys instanceof \Traversable) {
+            $keys = iterator_to_array($keys, false);
+        } elseif (!\is_array($keys)) {
+            throw new InvalidArgumentException(sprintf('Cache keys must be array or Traversable, "%s" given.', \is_object($keys) ? \get_class($keys) : \gettype($keys)));
+        }
+
+        try {
+            return $this->pool->deleteItems($keys);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        try {
+            return $this->pool->hasItem($key);
+        } catch (SimpleCacheException $e) {
+            throw $e;
+        } catch (Psr6CacheException $e) {
+            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/RedisCache.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Symfony\Component\Cache\Traits\RedisTrait;
+
+class RedisCache extends AbstractCache
+{
+    use RedisTrait;
+
+    /**
+     * @param \Redis|\RedisArray|\RedisCluster|\Predis\Client $redisClient
+     * @param string                                          $namespace
+     * @param int                                             $defaultLifetime
+     */
+    public function __construct($redisClient, $namespace = '', $defaultLifetime = 0)
+    {
+        $this->init($redisClient, $namespace, $defaultLifetime);
+    }
+}

modules/ps_facebook/vendor/symfony/cache/Simple/TraceableCache.php

@@ -0,0 +1,241 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Cache\Simple;
+
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Cache\PruneableInterface;
+use Symfony\Component\Cache\ResettableInterface;
+
+/**
+ * An adapter that collects data about all cache calls.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class TraceableCache implements CacheInterface, PruneableInterface, ResettableInterface
+{
+    private $pool;
+    private $miss;
+    private $calls = [];
+
+    public function __construct(CacheInterface $pool)
+    {
+        $this->pool = $pool;
+        $this->miss = new \stdClass();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get($key, $default = null)
+    {
+        $miss = null !== $default && \is_object($default) ? $default : $this->miss;
+        $event = $this->start(__FUNCTION__);
+        try {
+            $value = $this->pool->get($key, $miss);
+        } finally {
+            $event->end = microtime(true);
+        }
+        if ($event->result[$key] = $miss !== $value) {
+            ++$event->hits;
+        } else {
+            ++$event->misses;
+            $value = $default;
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function has($key)
+    {
+        $event = $this->start(__FUNCTION__);
+        try {
+            return $event->result[$key] = $this->pool->has($key);
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function delete($key)
+    {
+        $event = $this->start(__FUNCTION__);
+        try {
+            return $event->result[$key] = $this->pool->delete($key);
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($key, $value, $ttl = null)
+    {
+        $event = $this->start(__FUNCTION__);
+        try {
+            return $event->result[$key] = $this->pool->set($key, $value, $ttl);
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setMultiple($values, $ttl = null)
+    {
+        $event = $this->start(__FUNCTION__);
+        $event->result['keys'] = [];
+
+        if ($values instanceof \Traversable) {
+            $values = function () use ($values, $event) {
+                foreach ($values as $k => $v) {
+                    $event->result['keys'][] = $k;
+                    yield $k => $v;
+                }
+            };
+            $values = $values();
+        } elseif (\is_array($values)) {
+            $event->result['keys'] = array_keys($values);
+        }
+
+        try {
+            return $event->result['result'] = $this->pool->setMultiple($values, $ttl);
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMultiple($keys, $default = null)
+    {
+        $miss = null !== $default && \is_object($default) ? $default : $this->miss;
+        $event = $this->start(__FUNCTION__);
+        try {
+            $result = $this->pool->getMultiple($keys, $miss);
+        } finally {
+            $event->end = microtime(true);
+        }
+        $f = function () use ($result, $event, $miss, $default) {
+            $event->result = [];
+            foreach ($result as $key => $value) {
+                if ($event->result[$key] = $miss !== $value) {
+                    ++$event->hits;
+                } else {
+                    ++$event->misses;
+                    $value = $default;
+                }
+                yield $key => $value;
+            }
+        };
+
+        return $f();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        $event = $this->start(__FUNCTION__);
+        try {
+            return $event->result = $this->pool->clear();
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteMultiple($keys)
+    {
+        $event = $this->start(__FUNCTION__);
+        if ($keys instanceof \Traversable) {
+            $keys = $event->result['keys'] = iterator_to_array($keys, false);
+        } else {
+            $event->result['keys'] = $keys;
+        }
+        try {
+            return $event->result['result'] = $this->pool->deleteMultiple($keys);
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prune()
+    {
+        if (!$this->pool instanceof PruneableInterface) {
+            return false;
+        }
+        $event = $this->start(__FUNCTION__);
+        try {
+            return $event->result = $this->pool->prune();
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function reset()
+    {
+        if (!$this->pool instanceof ResettableInterface) {
+            return;
+        }
+        $event = $this->start(__FUNCTION__);
+        try {
+            $this->pool->reset();
+        } finally {
+            $event->end = microtime(true);
+        }
+    }
+
+    public function getCalls()
+    {
+        try {
+            return $this->calls;
+        } finally {
+            $this->calls = [];
+        }
+    }
+
+    private function start($name)
+    {
+        $this->calls[] = $event = new TraceableCacheEvent();
+        $event->name = $name;
+        $event->start = microtime(true);
+
+        return $event;
+    }
+}
+
+class TraceableCacheEvent
+{
+    public $name;
+    public $start;
+    public $end;
+    public $result;
+    public $hits = 0;
+    public $misses = 0;
+}