grommunio / grommunio-web

plugins/files/php/plugin.files.php

Switch Indentation +24 added lines, -24 removed lines

@@ -45,37 +45,37 @@
 
 			case 'server.index.load.custom':
 				switch ($data['name']) {
-				case 'files_get_recipients':
-					RecipientHandler::doGetRecipients();
-					break;
+					case 'files_get_recipients':
+						RecipientHandler::doGetRecipients();
+						break;
 
-				case 'download_file':
-					DownloadHandler::doDownload();
-					break;
+					case 'download_file':
+						DownloadHandler::doDownload();
+						break;
 
-				case 'upload_file':
-					UploadHandler::doUpload();
-					break;
+					case 'upload_file':
+						UploadHandler::doUpload();
+						break;
 
-				case 'form':
-					if (isset($_GET['backend'])) {
-						$backend = urldecode($_GET["backend"]);
-					}
-					else {
-						$backend = '';
-					}
-					$backendstore = Files\Backend\BackendStore::getInstance();
+					case 'form':
+						if (isset($_GET['backend'])) {
+							$backend = urldecode($_GET["backend"]);
+						}
+						else {
+							$backend = '';
+						}
+						$backendstore = Files\Backend\BackendStore::getInstance();
 
-					if ($backendstore->backendExists($backend)) {
-						$backendInstance = $backendstore->getInstanceOfBackend($backend);
-						$formdata = $backendInstance->getFormConfig();
+						if ($backendstore->backendExists($backend)) {
+							$backendInstance = $backendstore->getInstanceOfBackend($backend);
+							$formdata = $backendInstance->getFormConfig();
 
-						exit($formdata);
-					}
+							exit($formdata);
+						}
 
-						exit("Specified backend does not exist!");
+							exit("Specified backend does not exist!");
 
-					break;
+						break;
 			}
 			break;
 		}

plugins/files/php/lib/phpfastcache/bin/dependencies/Psr/SimpleCache/src/CacheInterface.php

Indentation +100 added lines, -100 removed lines

@@ -4,111 +4,111 @@
 
 interface CacheInterface
 {
-    /**
-     * Fetches a value from the cache.
-     *
-     * @param string $key     The unique key of this item in the cache.
-     * @param mixed  $default Default value to return if the key does not exist.
-     *
-     * @return mixed The value of the item from the cache, or $default in case of cache miss.
-     *
-     * @throws \Psr\SimpleCache\InvalidArgumentException
-     *   MUST be thrown if the $key string is not a legal value.
-     */
-    public function get($key, $default = null);
+	/**
+	 * Fetches a value from the cache.
+	 *
+	 * @param string $key     The unique key of this item in the cache.
+	 * @param mixed  $default Default value to return if the key does not exist.
+	 *
+	 * @return mixed The value of the item from the cache, or $default in case of cache miss.
+	 *
+	 * @throws \Psr\SimpleCache\InvalidArgumentException
+	 *   MUST be thrown if the $key string is not a legal value.
+	 */
+	public function get($key, $default = null);
 
-    /**
-     * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
-     *
-     * @param string                $key   The key of the item to store.
-     * @param mixed                 $value The value of the item to store, must be serializable.
-     * @param null|int|DateInterval $ttl   Optional. The TTL value of this item. If no value is sent and
-     *                                     the driver supports TTL then the library may set a default value
-     *                                     for it or let the driver take care of that.
-     *
-     * @return bool True on success and false on failure.
-     *
-     * @throws \Psr\SimpleCache\InvalidArgumentException
-     *   MUST be thrown if the $key string is not a legal value.
-     */
-    public function set($key, $value, $ttl = null);
+	/**
+	 * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
+	 *
+	 * @param string                $key   The key of the item to store.
+	 * @param mixed                 $value The value of the item to store, must be serializable.
+	 * @param null|int|DateInterval $ttl   Optional. The TTL value of this item. If no value is sent and
+	 *                                     the driver supports TTL then the library may set a default value
+	 *                                     for it or let the driver take care of that.
+	 *
+	 * @return bool True on success and false on failure.
+	 *
+	 * @throws \Psr\SimpleCache\InvalidArgumentException
+	 *   MUST be thrown if the $key string is not a legal value.
+	 */
+	public function set($key, $value, $ttl = null);
 
-    /**
-     * Delete an item from the cache by its unique key.
-     *
-     * @param string $key The unique cache key of the item to delete.
-     *
-     * @return bool True if the item was successfully removed. False if there was an error.
-     *
-     * @throws \Psr\SimpleCache\InvalidArgumentException
-     *   MUST be thrown if the $key string is not a legal value.
-     */
-    public function delete($key);
+	/**
+	 * Delete an item from the cache by its unique key.
+	 *
+	 * @param string $key The unique cache key of the item to delete.
+	 *
+	 * @return bool True if the item was successfully removed. False if there was an error.
+	 *
+	 * @throws \Psr\SimpleCache\InvalidArgumentException
+	 *   MUST be thrown if the $key string is not a legal value.
+	 */
+	public function delete($key);
 
-    /**
-     * Wipes clean the entire cache's keys.
-     *
-     * @return bool True on success and false on failure.
-     */
-    public function clear();
+	/**
+	 * Wipes clean the entire cache's keys.
+	 *
+	 * @return bool True on success and false on failure.
+	 */
+	public function clear();
 
-    /**
-     * Obtains multiple cache items by their unique keys.
-     *
-     * @param iterable $keys    A list of keys that can obtained in a single operation.
-     * @param mixed    $default Default value to return for keys that do not exist.
-     *
-     * @return iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value.
-     *
-     * @throws \Psr\SimpleCache\InvalidArgumentException
-     *   MUST be thrown if $keys is neither an array nor a Traversable,
-     *   or if any of the $keys are not a legal value.
-     */
-    public function getMultiple($keys, $default = null);
+	/**
+	 * Obtains multiple cache items by their unique keys.
+	 *
+	 * @param iterable $keys    A list of keys that can obtained in a single operation.
+	 * @param mixed    $default Default value to return for keys that do not exist.
+	 *
+	 * @return iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value.
+	 *
+	 * @throws \Psr\SimpleCache\InvalidArgumentException
+	 *   MUST be thrown if $keys is neither an array nor a Traversable,
+	 *   or if any of the $keys are not a legal value.
+	 */
+	public function getMultiple($keys, $default = null);
 
-    /**
-     * Persists a set of key => value pairs in the cache, with an optional TTL.
-     *
-     * @param iterable              $values A list of key => value pairs for a multiple-set operation.
-     * @param null|int|DateInterval $ttl    Optional. The TTL value of this item. If no value is sent and
-     *                                      the driver supports TTL then the library may set a default value
-     *                                      for it or let the driver take care of that.
-     *
-     * @return bool True on success and false on failure.
-     *
-     * @throws \Psr\SimpleCache\InvalidArgumentException
-     *   MUST be thrown if $values is neither an array nor a Traversable,
-     *   or if any of the $values are not a legal value.
-     */
-    public function setMultiple($values, $ttl = null);
+	/**
+	 * Persists a set of key => value pairs in the cache, with an optional TTL.
+	 *
+	 * @param iterable              $values A list of key => value pairs for a multiple-set operation.
+	 * @param null|int|DateInterval $ttl    Optional. The TTL value of this item. If no value is sent and
+	 *                                      the driver supports TTL then the library may set a default value
+	 *                                      for it or let the driver take care of that.
+	 *
+	 * @return bool True on success and false on failure.
+	 *
+	 * @throws \Psr\SimpleCache\InvalidArgumentException
+	 *   MUST be thrown if $values is neither an array nor a Traversable,
+	 *   or if any of the $values are not a legal value.
+	 */
+	public function setMultiple($values, $ttl = null);
 
-    /**
-     * Deletes multiple cache items in a single operation.
-     *
-     * @param iterable $keys A list of string-based keys to be deleted.
-     *
-     * @return bool True if the items were successfully removed. False if there was an error.
-     *
-     * @throws \Psr\SimpleCache\InvalidArgumentException
-     *   MUST be thrown if $keys is neither an array nor a Traversable,
-     *   or if any of the $keys are not a legal value.
-     */
-    public function deleteMultiple($keys);
+	/**
+	 * Deletes multiple cache items in a single operation.
+	 *
+	 * @param iterable $keys A list of string-based keys to be deleted.
+	 *
+	 * @return bool True if the items were successfully removed. False if there was an error.
+	 *
+	 * @throws \Psr\SimpleCache\InvalidArgumentException
+	 *   MUST be thrown if $keys is neither an array nor a Traversable,
+	 *   or if any of the $keys are not a legal value.
+	 */
+	public function deleteMultiple($keys);
 
-    /**
-     * Determines whether an item is present in the cache.
-     *
-     * NOTE: It is recommended that has() is only to be used for cache warming type purposes
-     * and not to be used within your live applications operations for get/set, as this method
-     * is subject to a race condition where your has() will return true and immediately after,
-     * another script can remove it making the state of your app out of date.
-     *
-     * @param string $key The cache item key.
-     *
-     * @return bool
-     *
-     * @throws \Psr\SimpleCache\InvalidArgumentException
-     *   MUST be thrown if the $key string is not a legal value.
-     */
-    public function has($key);
+	/**
+	 * Determines whether an item is present in the cache.
+	 *
+	 * NOTE: It is recommended that has() is only to be used for cache warming type purposes
+	 * and not to be used within your live applications operations for get/set, as this method
+	 * is subject to a race condition where your has() will return true and immediately after,
+	 * another script can remove it making the state of your app out of date.
+	 *
+	 * @param string $key The cache item key.
+	 *
+	 * @return bool
+	 *
+	 * @throws \Psr\SimpleCache\InvalidArgumentException
+	 *   MUST be thrown if the $key string is not a legal value.
+	 */
+	public function has($key);
 }

plugins/files/php/lib/phpfastcache/bin/dependencies/Psr/Cache/src/CacheItemPoolInterface.php

Indentation +113 added lines, -114 removed lines

@@ -14,126 +14,125 @@
  */
 interface CacheItemPoolInterface
 {
-    /**
-     * Returns a Cache Item representing the specified key.
-     *
-     * This method must always return a CacheItemInterface object, even in case of
-     * a cache miss. It MUST NOT return null.
-     *
-     * @param string $key
-     *   The key for which to return the corresponding Cache Item.
-     *
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
-     *   MUST be thrown.
-     *
-     * @return CacheItemInterface
-     *   The corresponding Cache Item.
-     */
-    public function getItem($key);
+	/**
+	 * Returns a Cache Item representing the specified key.
+	 *
+	 * This method must always return a CacheItemInterface object, even in case of
+	 * a cache miss. It MUST NOT return null.
+	 *
+	 * @param string $key
+	 *   The key for which to return the corresponding Cache Item.
+	 *
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 * @return CacheItemInterface
+	 *   The corresponding Cache Item.
+	 */
+	public function getItem($key);
 
-    /**
-     * Returns a traversable set of cache items.
-     *
-     * @param array $keys
-     * An indexed array of keys of items to retrieve.
-     *
-     * @throws InvalidArgumentException
-     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
-     *   MUST be thrown.
-     *
-     * @return array|\Traversable
-     *   A traversable collection of Cache Items keyed by the cache keys of
-     *   each item. A Cache item will be returned for each key, even if that
-     *   key is not found. However, if no keys are specified then an empty
-     *   traversable MUST be returned instead.
-     */
-    public function getItems(array $keys = array());
+	/**
+	 * Returns a traversable set of cache items.
+	 *
+	 * @param array $keys
+	 * An indexed array of keys of items to retrieve.
+	 *
+	 * @throws InvalidArgumentException
+	 *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 * @return array|\Traversable
+	 *   A traversable collection of Cache Items keyed by the cache keys of
+	 *   each item. A Cache item will be returned for each key, even if that
+	 *   key is not found. However, if no keys are specified then an empty
+	 *   traversable MUST be returned instead.
+	 */
+	public function getItems(array $keys = array());
 
-    /**
-     * Confirms if the cache contains specified cache item.
-     *
-     * Note: This method MAY avoid retrieving the cached value for performance reasons.
-     * This could result in a race condition with CacheItemInterface::get(). To avoid
-     * such situation use CacheItemInterface::isHit() instead.
-     *
-     * @param string $key
-     *    The key for which to check existence.
-     *
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
-     *   MUST be thrown.
-     *
-     * @return bool
-     *  True if item exists in the cache, false otherwise.
-     */
-    public function hasItem($key);
+	/**
+	 * Confirms if the cache contains specified cache item.
+	 *
+	 * Note: This method MAY avoid retrieving the cached value for performance reasons.
+	 * This could result in a race condition with CacheItemInterface::get(). To avoid
+	 * such situation use CacheItemInterface::isHit() instead.
+	 *
+	 * @param string $key
+	 *    The key for which to check existence.
+	 *
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 * @return bool
+	 *  True if item exists in the cache, false otherwise.
+	 */
+	public function hasItem($key);
 
-    /**
-     * Deletes all items in the pool.
-     *
-     * @return bool
-     *   True if the pool was successfully cleared. False if there was an error.
-     */
-    public function clear();
+	/**
+	 * Deletes all items in the pool.
+	 *
+	 * @return bool
+	 *   True if the pool was successfully cleared. False if there was an error.
+	 */
+	public function clear();
 
-    /**
-     * Removes the item from the pool.
-     *
-     * @param string $key
-     *   The key for which to delete
-     *
-     * @throws InvalidArgumentException
-     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
-     *   MUST be thrown.
-     *
-     * @return bool
-     *   True if the item was successfully removed. False if there was an error.
-     */
-    public function deleteItem($key);
+	/**
+	 * Removes the item from the pool.
+	 *
+	 * @param string $key
+	 *   The key for which to delete
+	 *
+	 * @throws InvalidArgumentException
+	 *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 * @return bool
+	 *   True if the item was successfully removed. False if there was an error.
+	 */
+	public function deleteItem($key);
 
-    /**
-     * Removes multiple items from the pool.
-     *
-     * @param array $keys
-     *   An array of keys that should be removed from the pool.
+	/**
+	 * Removes multiple items from the pool.
+	 *
+	 * @param array $keys
+	 *   An array of keys that should be removed from the pool.
+	 * @throws InvalidArgumentException
+	 *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
+	 *   MUST be thrown.
+	 *
+	 * @return bool
+	 *   True if the items were successfully removed. False if there was an error.
+	 */
+	public function deleteItems(array $keys);
 
-     * @throws InvalidArgumentException
-     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
-     *   MUST be thrown.
-     *
-     * @return bool
-     *   True if the items were successfully removed. False if there was an error.
-     */
-    public function deleteItems(array $keys);
+	/**
+	 * Persists a cache item immediately.
+	 *
+	 * @param CacheItemInterface $item
+	 *   The cache item to save.
+	 *
+	 * @return bool
+	 *   True if the item was successfully persisted. False if there was an error.
+	 */
+	public function save(CacheItemInterface $item);
 
-    /**
-     * Persists a cache item immediately.
-     *
-     * @param CacheItemInterface $item
-     *   The cache item to save.
-     *
-     * @return bool
-     *   True if the item was successfully persisted. False if there was an error.
-     */
-    public function save(CacheItemInterface $item);
+	/**
+	 * Sets a cache item to be persisted later.
+	 *
+	 * @param CacheItemInterface $item
+	 *   The cache item to save.
+	 *
+	 * @return bool
+	 *   False if the item could not be queued or if a commit was attempted and failed. True otherwise.
+	 */
+	public function saveDeferred(CacheItemInterface $item);
 
-    /**
-     * Sets a cache item to be persisted later.
-     *
-     * @param CacheItemInterface $item
-     *   The cache item to save.
-     *
-     * @return bool
-     *   False if the item could not be queued or if a commit was attempted and failed. True otherwise.
-     */
-    public function saveDeferred(CacheItemInterface $item);
-
-    /**
-     * Persists any deferred cache items.
-     *
-     * @return bool
-     *   True if all not-yet-saved items were successfully saved or there were none. False otherwise.
-     */
-    public function commit();
+	/**
+	 * Persists any deferred cache items.
+	 *
+	 * @return bool
+	 *   True if all not-yet-saved items were successfully saved or there were none. False otherwise.
+	 */
+	public function commit();
 }

plugins/files/php/lib/phpfastcache/bin/dependencies/Psr/Cache/src/CacheItemInterface.php

Indentation +74 added lines, -74 removed lines

@@ -24,83 +24,83 @@
  */
 interface CacheItemInterface
 {
-    /**
-     * Returns the key for the current cache item.
-     *
-     * The key is loaded by the Implementing Library, but should be available to
-     * the higher level callers when needed.
-     *
-     * @return string
-     *   The key string for this cache item.
-     */
-    public function getKey();
+	/**
+	 * Returns the key for the current cache item.
+	 *
+	 * The key is loaded by the Implementing Library, but should be available to
+	 * the higher level callers when needed.
+	 *
+	 * @return string
+	 *   The key string for this cache item.
+	 */
+	public function getKey();
 
-    /**
-     * Retrieves the value of the item from the cache associated with this object's key.
-     *
-     * The value returned must be identical to the value originally stored by set().
-     *
-     * If isHit() returns false, this method MUST return null. Note that null
-     * is a legitimate cached value, so the isHit() method SHOULD be used to
-     * differentiate between "null value was found" and "no value was found."
-     *
-     * @return mixed
-     *   The value corresponding to this cache item's key, or null if not found.
-     */
-    public function get();
+	/**
+	 * Retrieves the value of the item from the cache associated with this object's key.
+	 *
+	 * The value returned must be identical to the value originally stored by set().
+	 *
+	 * If isHit() returns false, this method MUST return null. Note that null
+	 * is a legitimate cached value, so the isHit() method SHOULD be used to
+	 * differentiate between "null value was found" and "no value was found."
+	 *
+	 * @return mixed
+	 *   The value corresponding to this cache item's key, or null if not found.
+	 */
+	public function get();
 
-    /**
-     * Confirms if the cache item lookup resulted in a cache hit.
-     *
-     * Note: This method MUST NOT have a race condition between calling isHit()
-     * and calling get().
-     *
-     * @return bool
-     *   True if the request resulted in a cache hit. False otherwise.
-     */
-    public function isHit();
+	/**
+	 * Confirms if the cache item lookup resulted in a cache hit.
+	 *
+	 * Note: This method MUST NOT have a race condition between calling isHit()
+	 * and calling get().
+	 *
+	 * @return bool
+	 *   True if the request resulted in a cache hit. False otherwise.
+	 */
+	public function isHit();
 
-    /**
-     * Sets the value represented by this cache item.
-     *
-     * The $value argument may be any item that can be serialized by PHP,
-     * although the method of serialization is left up to the Implementing
-     * Library.
-     *
-     * @param mixed $value
-     *   The serializable value to be stored.
-     *
-     * @return static
-     *   The invoked object.
-     */
-    public function set($value);
+	/**
+	 * Sets the value represented by this cache item.
+	 *
+	 * The $value argument may be any item that can be serialized by PHP,
+	 * although the method of serialization is left up to the Implementing
+	 * Library.
+	 *
+	 * @param mixed $value
+	 *   The serializable value to be stored.
+	 *
+	 * @return static
+	 *   The invoked object.
+	 */
+	public function set($value);
 
-    /**
-     * Sets the expiration time for this cache item.
-     *
-     * @param \DateTimeInterface $expiration
-     *   The point in time after which the item MUST be considered expired.
-     *   If null is passed explicitly, a default value MAY be used. If none is set,
-     *   the value should be stored permanently or for as long as the
-     *   implementation allows.
-     *
-     * @return static
-     *   The called object.
-     */
-    public function expiresAt($expiration);
+	/**
+	 * Sets the expiration time for this cache item.
+	 *
+	 * @param \DateTimeInterface $expiration
+	 *   The point in time after which the item MUST be considered expired.
+	 *   If null is passed explicitly, a default value MAY be used. If none is set,
+	 *   the value should be stored permanently or for as long as the
+	 *   implementation allows.
+	 *
+	 * @return static
+	 *   The called object.
+	 */
+	public function expiresAt($expiration);
 
-    /**
-     * Sets the expiration time for this cache item.
-     *
-     * @param int|\DateInterval $time
-     *   The period of time from the present after which the item MUST be considered
-     *   expired. An integer parameter is understood to be the time in seconds until
-     *   expiration. If null is passed explicitly, a default value MAY be used.
-     *   If none is set, the value should be stored permanently or for as long as the
-     *   implementation allows.
-     *
-     * @return static
-     *   The called object.
-     */
-    public function expiresAfter($time);
+	/**
+	 * Sets the expiration time for this cache item.
+	 *
+	 * @param int|\DateInterval $time
+	 *   The period of time from the present after which the item MUST be considered
+	 *   expired. An integer parameter is understood to be the time in seconds until
+	 *   expiration. If null is passed explicitly, a default value MAY be used.
+	 *   If none is set, the value should be stored permanently or for as long as the
+	 *   implementation allows.
+	 *
+	 * @return static
+	 *   The called object.
+	 */
+	public function expiresAfter($time);
 }

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Entities/DriverIO.php

Indentation +84 added lines, -84 removed lines

@@ -22,99 +22,99 @@
  */
 class DriverIO
 {
-    /**
-     * @var int
-     */
-    protected $writeHit = 0;
+	/**
+	 * @var int
+	 */
+	protected $writeHit = 0;
 
-    /**
-     * @var int
-     */
-    protected $readHit = 0;
+	/**
+	 * @var int
+	 */
+	protected $readHit = 0;
 
-    /**
-     * @var int
-     */
-    protected $readMiss = 0;
+	/**
+	 * @var int
+	 */
+	protected $readMiss = 0;
 
-    /**
-     * @return int
-     */
-    public function getWriteHit(): int
-    {
-        return $this->writeHit;
-    }
+	/**
+	 * @return int
+	 */
+	public function getWriteHit(): int
+	{
+		return $this->writeHit;
+	}
 
-    /**
-     * @param int $writeHit
-     * @return DriverIO
-     */
-    public function setWriteHit(int $writeHit): DriverIO
-    {
-        $this->writeHit = $writeHit;
-        return $this;
-    }
+	/**
+	 * @param int $writeHit
+	 * @return DriverIO
+	 */
+	public function setWriteHit(int $writeHit): DriverIO
+	{
+		$this->writeHit = $writeHit;
+		return $this;
+	}
 
-    /**
-     * @return DriverIO
-     */
-    public function incWriteHit(): DriverIO
-    {
-        $this->writeHit++;
-        return $this;
-    }
+	/**
+	 * @return DriverIO
+	 */
+	public function incWriteHit(): DriverIO
+	{
+		$this->writeHit++;
+		return $this;
+	}
 
-    /**
-     * @return int
-     */
-    public function getReadHit(): int
-    {
-        return $this->readHit;
-    }
+	/**
+	 * @return int
+	 */
+	public function getReadHit(): int
+	{
+		return $this->readHit;
+	}
 
-    /**
-     * @param int $readHit
-     * @return DriverIO
-     */
-    public function setReadHit(int $readHit): DriverIO
-    {
-        $this->readHit = $readHit;
-        return $this;
-    }
+	/**
+	 * @param int $readHit
+	 * @return DriverIO
+	 */
+	public function setReadHit(int $readHit): DriverIO
+	{
+		$this->readHit = $readHit;
+		return $this;
+	}
 
-    /**
-     * @return DriverIO
-     */
-    public function incReadHit(): DriverIO
-    {
-        $this->readHit++;
-        return $this;
-    }
+	/**
+	 * @return DriverIO
+	 */
+	public function incReadHit(): DriverIO
+	{
+		$this->readHit++;
+		return $this;
+	}
 
-    /**
-     * @return int
-     */
-    public function getReadMiss(): int
-    {
-        return $this->readMiss;
-    }
+	/**
+	 * @return int
+	 */
+	public function getReadMiss(): int
+	{
+		return $this->readMiss;
+	}
 
-    /**
-     * @param int $readMiss
-     * @return DriverIO
-     */
-    public function setReadMiss(int $readMiss): DriverIO
-    {
-        $this->readMiss = $readMiss;
-        return $this;
-    }
+	/**
+	 * @param int $readMiss
+	 * @return DriverIO
+	 */
+	public function setReadMiss(int $readMiss): DriverIO
+	{
+		$this->readMiss = $readMiss;
+		return $this;
+	}
 
-    /**
-     * @return DriverIO
-     */
-    public function incReadMiss(): DriverIO
-    {
-        $this->readMiss++;
-        return $this;
-    }
+	/**
+	 * @return DriverIO
+	 */
+	public function incReadMiss(): DriverIO
+	{
+		$this->readMiss++;
+		return $this;
+	}
 }
\ No newline at end of file

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Entities/DriverStatistic.php

Indentation +108 added lines, -108 removed lines

@@ -22,112 +22,112 @@
  */
 class DriverStatistic
 {
-    /**
-     * @var string
-     */
-    protected $info = '';
-
-    /**
-     * @var int
-     */
-    protected $size = 0;
-
-    /**
-     * @var string
-     */
-    protected $data = '';
-
-    /**
-     * @var mixed
-     */
-    protected $rawData;
-
-    /**
-     * @return string Return info or false if no information available
-     */
-    public function getInfo(): string
-    {
-        return $this->info;
-    }
-
-    /**
-     * @param string $info
-     * @return $this
-     */
-    public function setInfo(string $info): self
-    {
-        $this->info = $info;
-
-        return $this;
-    }
-
-    /**
-     * @return int Return size in octet or false if no information available
-     */
-    public function getSize(): int
-    {
-        return $this->size;
-    }
-
-    /**
-     * @param int $size
-     * @return $this
-     */
-    public function setSize(int $size)
-    {
-        $this->size = $size;
-
-        return $this;
-    }
-
-    /**
-     * @return mixed
-     */
-    public function getData()
-    {
-        return $this->data;
-    }
-
-    /**
-     * @param mixed $data
-     * @return $this
-     */
-    public function setData($data): self
-    {
-        $this->data = ($data ?: '');
-
-        return $this;
-    }
-
-    /**
-     * @return mixed
-     */
-    public function getRawData()
-    {
-        return $this->rawData;
-    }
-
-    /**
-     * @param mixed $raw
-     * @return $this
-     */
-    public function setRawData($raw): self
-    {
-        $this->rawData = $raw;
-
-        return $this;
-    }
-
-    /**
-     * @return array
-     */
-    public function getPublicDesc(): array
-    {
-        return [
-            'Info' => 'Cache Information',
-            'Size' => 'Cache Size',
-            'Data' => 'Cache items keys',
-            'RawData' => 'Cache raw data',
-        ];
-    }
+	/**
+	 * @var string
+	 */
+	protected $info = '';
+
+	/**
+	 * @var int
+	 */
+	protected $size = 0;
+
+	/**
+	 * @var string
+	 */
+	protected $data = '';
+
+	/**
+	 * @var mixed
+	 */
+	protected $rawData;
+
+	/**
+	 * @return string Return info or false if no information available
+	 */
+	public function getInfo(): string
+	{
+		return $this->info;
+	}
+
+	/**
+	 * @param string $info
+	 * @return $this
+	 */
+	public function setInfo(string $info): self
+	{
+		$this->info = $info;
+
+		return $this;
+	}
+
+	/**
+	 * @return int Return size in octet or false if no information available
+	 */
+	public function getSize(): int
+	{
+		return $this->size;
+	}
+
+	/**
+	 * @param int $size
+	 * @return $this
+	 */
+	public function setSize(int $size)
+	{
+		$this->size = $size;
+
+		return $this;
+	}
+
+	/**
+	 * @return mixed
+	 */
+	public function getData()
+	{
+		return $this->data;
+	}
+
+	/**
+	 * @param mixed $data
+	 * @return $this
+	 */
+	public function setData($data): self
+	{
+		$this->data = ($data ?: '');
+
+		return $this;
+	}
+
+	/**
+	 * @return mixed
+	 */
+	public function getRawData()
+	{
+		return $this->rawData;
+	}
+
+	/**
+	 * @param mixed $raw
+	 * @return $this
+	 */
+	public function setRawData($raw): self
+	{
+		$this->rawData = $raw;
+
+		return $this;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getPublicDesc(): array
+	{
+		return [
+			'Info' => 'Cache Information',
+			'Size' => 'Cache Size',
+			'Data' => 'Cache items keys',
+			'RawData' => 'Cache raw data',
+		];
+	}
 }
\ No newline at end of file

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Entities/ItemBatch.php

Indentation +36 added lines, -36 removed lines

@@ -24,40 +24,40 @@
  */
 class ItemBatch
 {
-    /**
-     * @var string
-     */
-    protected $itemKey;
-
-    /**
-     * @var DateTimeInterface
-     */
-    protected $itemDate;
-
-    /**
-     * ItemBatch constructor.
-     * @param string $itemKey
-     * @param DateTimeInterface $itemDate
-     */
-    public function __construct(string $itemKey, DateTimeInterface $itemDate)
-    {
-        $this->itemKey = $itemKey;
-        $this->itemDate = $itemDate;
-    }
-
-    /**
-     * @return string
-     */
-    public function getItemKey(): string
-    {
-        return $this->itemKey;
-    }
-
-    /**
-     * @return DateTimeInterface
-     */
-    public function getItemDate(): DateTimeInterface
-    {
-        return $this->itemDate;
-    }
+	/**
+	 * @var string
+	 */
+	protected $itemKey;
+
+	/**
+	 * @var DateTimeInterface
+	 */
+	protected $itemDate;
+
+	/**
+	 * ItemBatch constructor.
+	 * @param string $itemKey
+	 * @param DateTimeInterface $itemDate
+	 */
+	public function __construct(string $itemKey, DateTimeInterface $itemDate)
+	{
+		$this->itemKey = $itemKey;
+		$this->itemDate = $itemDate;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getItemKey(): string
+	{
+		return $this->itemKey;
+	}
+
+	/**
+	 * @return DateTimeInterface
+	 */
+	public function getItemDate(): DateTimeInterface
+	{
+		return $this->itemDate;
+	}
 }
\ No newline at end of file

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/EventManager.php

Indentation +87 added lines, -87 removed lines

@@ -47,100 +47,100 @@
  */
 class EventManager implements EventManagerInterface
 {
-    public const ON_EVERY_EVENT = '__every';
+	public const ON_EVERY_EVENT = '__every';
 
-    /**
-     * @var $this
-     */
-    protected static $instance;
+	/**
+	 * @var $this
+	 */
+	protected static $instance;
 
-    /**
-     * @var array
-     */
-    protected $events = [
-        self::ON_EVERY_EVENT => []
-    ];
+	/**
+	 * @var array
+	 */
+	protected $events = [
+		self::ON_EVERY_EVENT => []
+	];
 
-    /**
-     * EventManager constructor.
-     */
-    final protected function __construct()
-    {
-        // The constructor should not be instantiated externally
-    }
+	/**
+	 * EventManager constructor.
+	 */
+	final protected function __construct()
+	{
+		// The constructor should not be instantiated externally
+	}
 
-    /**
-     * @return EventManagerInterface
-     */
-    public static function getInstance(): EventManagerInterface
-    {
-        return (self::$instance ?: self::$instance = new self);
-    }
+	/**
+	 * @return EventManagerInterface
+	 */
+	public static function getInstance(): EventManagerInterface
+	{
+		return (self::$instance ?: self::$instance = new self);
+	}
 
-    /**
-     * @param string $eventName
-     * @param array ...$args
-     */
-    public function dispatch(string $eventName, ...$args): void
-    {
-        /**
-         * Replace array_key_exists by isset
-         * due to performance issue on huge
-         * loop dispatching operations
-         */
-        if (isset($this->events[$eventName]) && $eventName !== self::ON_EVERY_EVENT) {
-            foreach ($this->events[$eventName] as $event) {
-                $event(... $args);
-            }
-        }
-        foreach ($this->events[self::ON_EVERY_EVENT] as $event) {
-            $event($eventName, ...$args);
-        }
-    }
+	/**
+	 * @param string $eventName
+	 * @param array ...$args
+	 */
+	public function dispatch(string $eventName, ...$args): void
+	{
+		/**
+		 * Replace array_key_exists by isset
+		 * due to performance issue on huge
+		 * loop dispatching operations
+		 */
+		if (isset($this->events[$eventName]) && $eventName !== self::ON_EVERY_EVENT) {
+			foreach ($this->events[$eventName] as $event) {
+				$event(... $args);
+			}
+		}
+		foreach ($this->events[self::ON_EVERY_EVENT] as $event) {
+			$event($eventName, ...$args);
+		}
+	}
 
-    /**
-     * @param string $name
-     * @param array $arguments
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws BadMethodCallException
-     */
-    public function __call(string $name, array $arguments): void
-    {
-        if (\strpos($name, 'on') === 0) {
-            $name = \substr($name, 2);
-            if (\is_callable($arguments[0])) {
-                if (isset($arguments[1]) && \is_string($arguments[0])) {
-                    $this->events[$name][$arguments[1]] = $arguments[0];
-                } else {
-                    $this->events[$name][] = $arguments[0];
-                }
-            } else {
-                throw new PhpfastcacheInvalidArgumentException(\sprintf('Expected Callable, got "%s"', \gettype($arguments[0])));
-            }
-        } else {
-            throw new BadMethodCallException('An event must start with "on" such as "onCacheGetItem"');
-        }
-    }
+	/**
+	 * @param string $name
+	 * @param array $arguments
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws BadMethodCallException
+	 */
+	public function __call(string $name, array $arguments): void
+	{
+		if (\strpos($name, 'on') === 0) {
+			$name = \substr($name, 2);
+			if (\is_callable($arguments[0])) {
+				if (isset($arguments[1]) && \is_string($arguments[0])) {
+					$this->events[$name][$arguments[1]] = $arguments[0];
+				} else {
+					$this->events[$name][] = $arguments[0];
+				}
+			} else {
+				throw new PhpfastcacheInvalidArgumentException(\sprintf('Expected Callable, got "%s"', \gettype($arguments[0])));
+			}
+		} else {
+			throw new BadMethodCallException('An event must start with "on" such as "onCacheGetItem"');
+		}
+	}
 
-    /**
-     * @param callable $callback
-     * @param string $callbackName
-     */
-    public function onEveryEvents(callable $callback, string $callbackName): void
-    {
-        $this->events[self::ON_EVERY_EVENT][$callbackName] = $callback;
-    }
+	/**
+	 * @param callable $callback
+	 * @param string $callbackName
+	 */
+	public function onEveryEvents(callable $callback, string $callbackName): void
+	{
+		$this->events[self::ON_EVERY_EVENT][$callbackName] = $callback;
+	}
 
-    /**
-     * @param string $eventName
-     * @param string $callbackName
-     * @return bool
-     */
-    public function unbindEventCallback(string $eventName, string $callbackName): bool
-    {
-        $return = isset($this->events[$eventName][$callbackName]);
-        unset($this->events[$eventName][$callbackName]);
+	/**
+	 * @param string $eventName
+	 * @param string $callbackName
+	 * @return bool
+	 */
+	public function unbindEventCallback(string $eventName, string $callbackName): bool
+	{
+		$return = isset($this->events[$eventName][$callbackName]);
+		unset($this->events[$eventName][$callbackName]);
 
-        return $return;
-    }
+		return $return;
+	}
 }

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/CacheManager.php

Indentation +449 added lines, -449 removed lines

@@ -21,13 +21,13 @@ 
 use Phpfastcache\Config\ConfigurationOptionInterface;
 use Phpfastcache\Core\Pool\ExtendedCacheItemPoolInterface;
 use Phpfastcache\Exceptions\{PhpfastcacheDriverCheckException,
-    PhpfastcacheDriverException,
-    PhpfastcacheDriverNotFoundException,
-    PhpfastcacheInstanceNotFoundException,
-    PhpfastcacheInvalidArgumentException,
-    PhpfastcacheInvalidConfigurationException,
-    PhpfastcacheLogicException,
-    PhpfastcacheUnsupportedOperationException
+	PhpfastcacheDriverException,
+	PhpfastcacheDriverNotFoundException,
+	PhpfastcacheInstanceNotFoundException,
+	PhpfastcacheInvalidArgumentException,
+	PhpfastcacheInvalidConfigurationException,
+	PhpfastcacheLogicException,
+	PhpfastcacheUnsupportedOperationException
 };
 use Phpfastcache\Util\ClassNamespaceResolverTrait;
 
@@ -59,447 +59,447 @@ 
  */
 class CacheManager
 {
-    public const CORE_DRIVER_NAMESPACE = 'Phpfastcache\Drivers\\';
-
-    use ClassNamespaceResolverTrait;
-
-    /**
-     * @var ConfigurationOption
-     */
-    protected static $config;
-    /**
-     * @var string
-     */
-    protected static $namespacePath;
-
-    /**
-     * @var ExtendedCacheItemPoolInterface[]
-     */
-    protected static $instances = [];
-
-    /**
-     * @var array
-     */
-    protected static $driverOverrides = [];
-
-    /**
-     * @var array
-     */
-    protected static $driverCustoms = [];
-
-    /**
-     * @var array
-     */
-    protected static $badPracticeOmeter = [];
-
-    /**
-     * CacheManager constructor.
-     */
-    final protected function __construct()
-    {
-        // The cache manager is not meant to be instantiated
-    }
-
-    /**
-     * @param string $instanceId
-     * @return ExtendedCacheItemPoolInterface
-     * @throws PhpfastcacheInstanceNotFoundException
-     */
-    public static function getInstanceById(string $instanceId): ExtendedCacheItemPoolInterface
-    {
-        if (isset(self::$instances[$instanceId])) {
-            return self::$instances[$instanceId];
-        }
-
-        throw new PhpfastcacheInstanceNotFoundException(sprintf('Instance ID %s not found', $instanceId));
-    }
-
-    /**
-     * Return the list of instances
-     *
-     * @return ExtendedCacheItemPoolInterface[]
-     */
-    public static function getInstances(): array
-    {
-        return self::$instances;
-    }
-
-    /**
-     * This method is intended for internal
-     * use only and should not be used for
-     * any external development use the
-     * getInstances() method instead
-     *
-     * @return ExtendedCacheItemPoolInterface[]
-     * @internal
-     * @todo Use a proper way to passe them as a reference ?
-     */
-    public static function &getInternalInstances(): array
-    {
-        return self::$instances;
-    }
-
-    /**
-     * @param string $name
-     * @param array $arguments
-     * @return ExtendedCacheItemPoolInterface
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheDriverNotFoundException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheInvalidConfigurationException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public static function __callStatic(string $name, array $arguments): ExtendedCacheItemPoolInterface
-    {
-        $options = (\array_key_exists(0, $arguments) && \is_array($arguments) ? $arguments[0] : []);
-
-        return self::getInstance($name, $options);
-    }
-
-    /**
-     * @param string $driver
-     * @param ConfigurationOptionInterface $config
-     * @param string|null $instanceId
-     * @return ExtendedCacheItemPoolInterface|AggregatablePoolInterface
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheDriverNotFoundException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheInvalidConfigurationException
-     * @throws PhpfastcacheLogicException
-     * @throws \ReflectionException
-     */
-    public static function getInstance(string $driver, ?ConfigurationOptionInterface $config = null, ?string $instanceId = null): ExtendedCacheItemPoolInterface
-    {
-        $config = self::validateConfig($config);
-        $driver = self::standardizeDriverName($driver);
-
-        $instanceId = $instanceId ?: md5($driver . \serialize(\array_filter($config->toArray(), static function ($val){
-            return !\is_callable($val);
-        })));
-
-        if (!isset(self::$instances[$instanceId])) {
-            self::$badPracticeOmeter[$driver] = 1;
-            $driverClass = self::validateDriverClass(self::getDriverClass($driver));
-
-            if (\class_exists($driverClass)) {
-                $configClass = $driverClass::getConfigClass();
-                self::$instances[$instanceId] = new $driverClass(new $configClass($config->toArray()), $instanceId);
-                self::$instances[$instanceId]->setEventManager(EventManager::getInstance());
-            } else {
-                throw new PhpfastcacheDriverNotFoundException(sprintf('The driver "%s" does not exists', $driver));
-            }
-        } else {
-            if (self::$badPracticeOmeter[$driver] >= 2) {
-                \trigger_error(
-                    '[' . $driver . '] Calling many times CacheManager::getInstance() for already instanced drivers is a bad practice and have a significant impact on performances.
+	public const CORE_DRIVER_NAMESPACE = 'Phpfastcache\Drivers\\';
+
+	use ClassNamespaceResolverTrait;
+
+	/**
+	 * @var ConfigurationOption
+	 */
+	protected static $config;
+	/**
+	 * @var string
+	 */
+	protected static $namespacePath;
+
+	/**
+	 * @var ExtendedCacheItemPoolInterface[]
+	 */
+	protected static $instances = [];
+
+	/**
+	 * @var array
+	 */
+	protected static $driverOverrides = [];
+
+	/**
+	 * @var array
+	 */
+	protected static $driverCustoms = [];
+
+	/**
+	 * @var array
+	 */
+	protected static $badPracticeOmeter = [];
+
+	/**
+	 * CacheManager constructor.
+	 */
+	final protected function __construct()
+	{
+		// The cache manager is not meant to be instantiated
+	}
+
+	/**
+	 * @param string $instanceId
+	 * @return ExtendedCacheItemPoolInterface
+	 * @throws PhpfastcacheInstanceNotFoundException
+	 */
+	public static function getInstanceById(string $instanceId): ExtendedCacheItemPoolInterface
+	{
+		if (isset(self::$instances[$instanceId])) {
+			return self::$instances[$instanceId];
+		}
+
+		throw new PhpfastcacheInstanceNotFoundException(sprintf('Instance ID %s not found', $instanceId));
+	}
+
+	/**
+	 * Return the list of instances
+	 *
+	 * @return ExtendedCacheItemPoolInterface[]
+	 */
+	public static function getInstances(): array
+	{
+		return self::$instances;
+	}
+
+	/**
+	 * This method is intended for internal
+	 * use only and should not be used for
+	 * any external development use the
+	 * getInstances() method instead
+	 *
+	 * @return ExtendedCacheItemPoolInterface[]
+	 * @internal
+	 * @todo Use a proper way to passe them as a reference ?
+	 */
+	public static function &getInternalInstances(): array
+	{
+		return self::$instances;
+	}
+
+	/**
+	 * @param string $name
+	 * @param array $arguments
+	 * @return ExtendedCacheItemPoolInterface
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheDriverNotFoundException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheInvalidConfigurationException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public static function __callStatic(string $name, array $arguments): ExtendedCacheItemPoolInterface
+	{
+		$options = (\array_key_exists(0, $arguments) && \is_array($arguments) ? $arguments[0] : []);
+
+		return self::getInstance($name, $options);
+	}
+
+	/**
+	 * @param string $driver
+	 * @param ConfigurationOptionInterface $config
+	 * @param string|null $instanceId
+	 * @return ExtendedCacheItemPoolInterface|AggregatablePoolInterface
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheDriverNotFoundException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheInvalidConfigurationException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \ReflectionException
+	 */
+	public static function getInstance(string $driver, ?ConfigurationOptionInterface $config = null, ?string $instanceId = null): ExtendedCacheItemPoolInterface
+	{
+		$config = self::validateConfig($config);
+		$driver = self::standardizeDriverName($driver);
+
+		$instanceId = $instanceId ?: md5($driver . \serialize(\array_filter($config->toArray(), static function ($val){
+			return !\is_callable($val);
+		})));
+
+		if (!isset(self::$instances[$instanceId])) {
+			self::$badPracticeOmeter[$driver] = 1;
+			$driverClass = self::validateDriverClass(self::getDriverClass($driver));
+
+			if (\class_exists($driverClass)) {
+				$configClass = $driverClass::getConfigClass();
+				self::$instances[$instanceId] = new $driverClass(new $configClass($config->toArray()), $instanceId);
+				self::$instances[$instanceId]->setEventManager(EventManager::getInstance());
+			} else {
+				throw new PhpfastcacheDriverNotFoundException(sprintf('The driver "%s" does not exists', $driver));
+			}
+		} else {
+			if (self::$badPracticeOmeter[$driver] >= 2) {
+				\trigger_error(
+					'[' . $driver . '] Calling many times CacheManager::getInstance() for already instanced drivers is a bad practice and have a significant impact on performances.
            See https://github.com/PHPSocialNetwork/phpfastcache/wiki/[V5]-Why-calling-getInstance%28%29-each-time-is-a-bad-practice-%3F'
-                );
-            }
-        }
-
-        self::$badPracticeOmeter[$driver]++;
-
-        return self::$instances[$instanceId];
-    }
-
-    /**
-     * @param ConfigurationOptionInterface|null $config
-     * @return ConfigurationOption
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheInvalidConfigurationException
-     * @throws \ReflectionException
-     */
-    protected static function validateConfig(?ConfigurationOptionInterface $config): ConfigurationOption
-    {
-        if ($config === null) {
-            $config = self::getDefaultConfig();
-        } else {
-            if (!($config instanceof ConfigurationOption)) {
-                throw new PhpfastcacheInvalidArgumentException(\sprintf('Unsupported config type: %s', \gettype($config)));
-            }
-        }
-
-        return $config;
-    }
-
-    /**
-     * @return ConfigurationOptionInterface
-     * @throws PhpfastcacheInvalidConfigurationException
-     * @throws \ReflectionException
-     */
-    public static function getDefaultConfig(): ConfigurationOptionInterface
-    {
-        return self::$config ?: self::$config = new ConfigurationOption();
-    }
-
-    /**
-     * @param string $driverName
-     * @return string
-     */
-    public static function standardizeDriverName(string $driverName): string
-    {
-        return \ucfirst(\strtolower(\trim($driverName)));
-    }
-
-    /**
-     * @param string $driverClass
-     * @return string|ExtendedCacheItemPoolInterface
-     * @throws PhpfastcacheDriverException
-     */
-    protected static function validateDriverClass(string $driverClass): string
-    {
-        if (!\is_a($driverClass, ExtendedCacheItemPoolInterface::class, true)) {
-            throw new PhpfastcacheDriverException(
-                \sprintf(
-                    'Class "%s" does not implement "%s"',
-                    $driverClass,
-                    ExtendedCacheItemPoolInterface::class
-                )
-            );
-        }
-        return $driverClass;
-    }
-
-    /**
-     * @param string $driverName
-     * @return string
-     */
-    public static function getDriverClass(string $driverName): string
-    {
-        if (!empty(self::$driverCustoms[$driverName])) {
-            $driverClass = self::$driverCustoms[$driverName];
-        } else {
-            if (!empty(self::$driverOverrides[$driverName])) {
-                $driverClass = self::$driverOverrides[$driverName];
-            } else {
-                $driverClass = self::getNamespacePath() . $driverName . '\Driver';
-            }
-        }
-
-        return $driverClass;
-    }
-
-    /**
-     * @return string
-     */
-    public static function getNamespacePath(): string
-    {
-        return self::$namespacePath ?: self::getDefaultNamespacePath();
-    }
-
-    /**
-     * @return string
-     */
-    public static function getDefaultNamespacePath(): string
-    {
-        return self::CORE_DRIVER_NAMESPACE;
-    }
-
-    /**
-     * @return bool
-     */
-    public static function clearInstances(): bool
-    {
-        self::$instances = [];
-
-        \gc_collect_cycles();
-        return !\count(self::$instances);
-    }
-
-    /**
-     * @param ExtendedCacheItemPoolInterface $cachePoolInstance
-     * @return bool
-     * @since 7.0.4
-     */
-    public static function clearInstance(ExtendedCacheItemPoolInterface $cachePoolInstance): bool
-    {
-        $found = false;
-        self::$instances = \array_filter(
-            \array_map(
-                static function (ExtendedCacheItemPoolInterface $cachePool) use ($cachePoolInstance, &$found) {
-                    if (\spl_object_hash($cachePool) === \spl_object_hash($cachePoolInstance)) {
-                        $found = true;
-                        return null;
-                    }
-                    return $cachePool;
-                },
-                self::$instances
-            )
-        );
-
-        return $found;
-    }
-
-    /**
-     * @param ConfigurationOption $config
-     */
-    public static function setDefaultConfig(ConfigurationOption $config): void
-    {
-        self::$config = $config;
-    }
-
-    /**
-     * @param string $driverName
-     * @param string $className
-     * @return void
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheUnsupportedOperationException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public static function addCustomDriver(string $driverName, string $className): void
-    {
-        $driverName = self::standardizeDriverName($driverName);
-
-        if (empty($driverName)) {
-            throw new PhpfastcacheInvalidArgumentException("Can't add a custom driver because its name is empty");
-        }
-
-        if (!\class_exists($className)) {
-            throw new PhpfastcacheInvalidArgumentException(
-                \sprintf("Can't add '%s' because the class '%s' does not exists", $driverName, $className)
-            );
-        }
-
-        if (!empty(self::$driverCustoms[$driverName])) {
-            throw new PhpfastcacheLogicException(\sprintf("Driver '%s' has been already added", $driverName));
-        }
-
-        if (\in_array($driverName, self::getDriverList(), true)) {
-            throw new PhpfastcacheLogicException(\sprintf("Driver '%s' is already a part of the PhpFastCache core", $driverName));
-        }
-
-        self::$driverCustoms[$driverName] = $className;
-    }
-
-    /**
-     * Return the list of available drivers Capitalized
-     * with optional FQCN as key
-     *
-     * @param bool $FQCNAsKey Describe keys with Full Qualified Class Name
-     * @return string[]
-     * @throws PhpfastcacheUnsupportedOperationException
-     */
-    public static function getDriverList(bool $FQCNAsKey = false): array
-    {
-        static $driverList;
-
-        if (self::getDefaultNamespacePath() === self::getNamespacePath()) {
-            if ($driverList === null) {
-                $prefix = self::CORE_DRIVER_NAMESPACE;
-                $classMap = self::createClassMap(__DIR__ . '/Drivers');
-                $driverList = [];
-
-                foreach ($classMap as $class => $file) {
-                    $driverList[] = \str_replace($prefix, '', \substr($class, 0, \strrpos($class, '\\')));
-                }
-
-                $driverList = \array_values(\array_unique($driverList));
-            }
-
-            $driverList = \array_merge($driverList, \array_keys(self::$driverCustoms));
-
-            if ($FQCNAsKey) {
-                $realDriverList = [];
-                foreach ($driverList as $driverName) {
-                    $realDriverList[self::getDriverClass($driverName)] = $driverName;
-                }
-                $driverList = $realDriverList;
-            }
-
-            \asort($driverList);
-
-            return $driverList;
-        }
-
-        throw new PhpfastcacheUnsupportedOperationException('Cannot get the driver list if the default namespace path has changed.');
-    }
-
-    /**
-     * @param string $driverName
-     * @return void
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public static function removeCustomDriver(string $driverName): void
-    {
-        $driverName = self::standardizeDriverName($driverName);
-
-        if (empty($driverName)) {
-            throw new PhpfastcacheInvalidArgumentException("Can't remove a custom driver because its name is empty");
-        }
-
-        if (!isset(self::$driverCustoms[$driverName])) {
-            throw new PhpfastcacheLogicException(\sprintf("Driver '%s' does not exists", $driverName));
-        }
-
-        unset(self::$driverCustoms[$driverName]);
-    }
-
-    /**
-     * @param string $driverName
-     * @param string $className
-     * @return void
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheUnsupportedOperationException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public static function addCoreDriverOverride(string $driverName, string $className): void
-    {
-        $driverName = self::standardizeDriverName($driverName);
-
-        if (empty($driverName)) {
-            throw new PhpfastcacheInvalidArgumentException("Can't add a core driver override because its name is empty");
-        }
-
-        if (!\class_exists($className)) {
-            throw new PhpfastcacheInvalidArgumentException(
-                \sprintf("Can't override '%s' because the class '%s' does not exists", $driverName, $className)
-            );
-        }
-
-        if (!empty(self::$driverOverrides[$driverName])) {
-            throw new PhpfastcacheLogicException(\sprintf("Driver '%s' has been already overridden", $driverName));
-        }
-
-        if (!\in_array($driverName, self::getDriverList(), true)) {
-            throw new PhpfastcacheLogicException(\sprintf("Driver '%s' can't be overridden since its not a part of the PhpFastCache core", $driverName));
-        }
-
-        if (!\is_subclass_of($className, self::CORE_DRIVER_NAMESPACE . $driverName . '\\Driver', true)) {
-            throw new PhpfastcacheLogicException(
-                \sprintf(
-                    "Can't override '%s' because the class '%s' MUST extend '%s'",
-                    $driverName,
-                    $className,
-                    self::CORE_DRIVER_NAMESPACE . $driverName . '\\Driver'
-                )
-            );
-        }
-
-        self::$driverOverrides[$driverName] = $className;
-    }
-
-    /**
-     * @param string $driverName
-     * @return void
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public static function removeCoreDriverOverride(string $driverName): void
-    {
-        $driverName = self::standardizeDriverName($driverName);
-
-        if (empty($driverName)) {
-            throw new PhpfastcacheInvalidArgumentException("Can't remove a core driver override because its name is empty");
-        }
-
-        if (!isset(self::$driverOverrides[$driverName])) {
-            throw new PhpfastcacheLogicException(\sprintf("Driver '%s' were not overridden", $driverName));
-        }
-
-        unset(self::$driverOverrides[$driverName]);
-    }
+				);
+			}
+		}
+
+		self::$badPracticeOmeter[$driver]++;
+
+		return self::$instances[$instanceId];
+	}
+
+	/**
+	 * @param ConfigurationOptionInterface|null $config
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheInvalidConfigurationException
+	 * @throws \ReflectionException
+	 */
+	protected static function validateConfig(?ConfigurationOptionInterface $config): ConfigurationOption
+	{
+		if ($config === null) {
+			$config = self::getDefaultConfig();
+		} else {
+			if (!($config instanceof ConfigurationOption)) {
+				throw new PhpfastcacheInvalidArgumentException(\sprintf('Unsupported config type: %s', \gettype($config)));
+			}
+		}
+
+		return $config;
+	}
+
+	/**
+	 * @return ConfigurationOptionInterface
+	 * @throws PhpfastcacheInvalidConfigurationException
+	 * @throws \ReflectionException
+	 */
+	public static function getDefaultConfig(): ConfigurationOptionInterface
+	{
+		return self::$config ?: self::$config = new ConfigurationOption();
+	}
+
+	/**
+	 * @param string $driverName
+	 * @return string
+	 */
+	public static function standardizeDriverName(string $driverName): string
+	{
+		return \ucfirst(\strtolower(\trim($driverName)));
+	}
+
+	/**
+	 * @param string $driverClass
+	 * @return string|ExtendedCacheItemPoolInterface
+	 * @throws PhpfastcacheDriverException
+	 */
+	protected static function validateDriverClass(string $driverClass): string
+	{
+		if (!\is_a($driverClass, ExtendedCacheItemPoolInterface::class, true)) {
+			throw new PhpfastcacheDriverException(
+				\sprintf(
+					'Class "%s" does not implement "%s"',
+					$driverClass,
+					ExtendedCacheItemPoolInterface::class
+				)
+			);
+		}
+		return $driverClass;
+	}
+
+	/**
+	 * @param string $driverName
+	 * @return string
+	 */
+	public static function getDriverClass(string $driverName): string
+	{
+		if (!empty(self::$driverCustoms[$driverName])) {
+			$driverClass = self::$driverCustoms[$driverName];
+		} else {
+			if (!empty(self::$driverOverrides[$driverName])) {
+				$driverClass = self::$driverOverrides[$driverName];
+			} else {
+				$driverClass = self::getNamespacePath() . $driverName . '\Driver';
+			}
+		}
+
+		return $driverClass;
+	}
+
+	/**
+	 * @return string
+	 */
+	public static function getNamespacePath(): string
+	{
+		return self::$namespacePath ?: self::getDefaultNamespacePath();
+	}
+
+	/**
+	 * @return string
+	 */
+	public static function getDefaultNamespacePath(): string
+	{
+		return self::CORE_DRIVER_NAMESPACE;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public static function clearInstances(): bool
+	{
+		self::$instances = [];
+
+		\gc_collect_cycles();
+		return !\count(self::$instances);
+	}
+
+	/**
+	 * @param ExtendedCacheItemPoolInterface $cachePoolInstance
+	 * @return bool
+	 * @since 7.0.4
+	 */
+	public static function clearInstance(ExtendedCacheItemPoolInterface $cachePoolInstance): bool
+	{
+		$found = false;
+		self::$instances = \array_filter(
+			\array_map(
+				static function (ExtendedCacheItemPoolInterface $cachePool) use ($cachePoolInstance, &$found) {
+					if (\spl_object_hash($cachePool) === \spl_object_hash($cachePoolInstance)) {
+						$found = true;
+						return null;
+					}
+					return $cachePool;
+				},
+				self::$instances
+			)
+		);
+
+		return $found;
+	}
+
+	/**
+	 * @param ConfigurationOption $config
+	 */
+	public static function setDefaultConfig(ConfigurationOption $config): void
+	{
+		self::$config = $config;
+	}
+
+	/**
+	 * @param string $driverName
+	 * @param string $className
+	 * @return void
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheUnsupportedOperationException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public static function addCustomDriver(string $driverName, string $className): void
+	{
+		$driverName = self::standardizeDriverName($driverName);
+
+		if (empty($driverName)) {
+			throw new PhpfastcacheInvalidArgumentException("Can't add a custom driver because its name is empty");
+		}
+
+		if (!\class_exists($className)) {
+			throw new PhpfastcacheInvalidArgumentException(
+				\sprintf("Can't add '%s' because the class '%s' does not exists", $driverName, $className)
+			);
+		}
+
+		if (!empty(self::$driverCustoms[$driverName])) {
+			throw new PhpfastcacheLogicException(\sprintf("Driver '%s' has been already added", $driverName));
+		}
+
+		if (\in_array($driverName, self::getDriverList(), true)) {
+			throw new PhpfastcacheLogicException(\sprintf("Driver '%s' is already a part of the PhpFastCache core", $driverName));
+		}
+
+		self::$driverCustoms[$driverName] = $className;
+	}
+
+	/**
+	 * Return the list of available drivers Capitalized
+	 * with optional FQCN as key
+	 *
+	 * @param bool $FQCNAsKey Describe keys with Full Qualified Class Name
+	 * @return string[]
+	 * @throws PhpfastcacheUnsupportedOperationException
+	 */
+	public static function getDriverList(bool $FQCNAsKey = false): array
+	{
+		static $driverList;
+
+		if (self::getDefaultNamespacePath() === self::getNamespacePath()) {
+			if ($driverList === null) {
+				$prefix = self::CORE_DRIVER_NAMESPACE;
+				$classMap = self::createClassMap(__DIR__ . '/Drivers');
+				$driverList = [];
+
+				foreach ($classMap as $class => $file) {
+					$driverList[] = \str_replace($prefix, '', \substr($class, 0, \strrpos($class, '\\')));
+				}
+
+				$driverList = \array_values(\array_unique($driverList));
+			}
+
+			$driverList = \array_merge($driverList, \array_keys(self::$driverCustoms));
+
+			if ($FQCNAsKey) {
+				$realDriverList = [];
+				foreach ($driverList as $driverName) {
+					$realDriverList[self::getDriverClass($driverName)] = $driverName;
+				}
+				$driverList = $realDriverList;
+			}
+
+			\asort($driverList);
+
+			return $driverList;
+		}
+
+		throw new PhpfastcacheUnsupportedOperationException('Cannot get the driver list if the default namespace path has changed.');
+	}
+
+	/**
+	 * @param string $driverName
+	 * @return void
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public static function removeCustomDriver(string $driverName): void
+	{
+		$driverName = self::standardizeDriverName($driverName);
+
+		if (empty($driverName)) {
+			throw new PhpfastcacheInvalidArgumentException("Can't remove a custom driver because its name is empty");
+		}
+
+		if (!isset(self::$driverCustoms[$driverName])) {
+			throw new PhpfastcacheLogicException(\sprintf("Driver '%s' does not exists", $driverName));
+		}
+
+		unset(self::$driverCustoms[$driverName]);
+	}
+
+	/**
+	 * @param string $driverName
+	 * @param string $className
+	 * @return void
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheUnsupportedOperationException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public static function addCoreDriverOverride(string $driverName, string $className): void
+	{
+		$driverName = self::standardizeDriverName($driverName);
+
+		if (empty($driverName)) {
+			throw new PhpfastcacheInvalidArgumentException("Can't add a core driver override because its name is empty");
+		}
+
+		if (!\class_exists($className)) {
+			throw new PhpfastcacheInvalidArgumentException(
+				\sprintf("Can't override '%s' because the class '%s' does not exists", $driverName, $className)
+			);
+		}
+
+		if (!empty(self::$driverOverrides[$driverName])) {
+			throw new PhpfastcacheLogicException(\sprintf("Driver '%s' has been already overridden", $driverName));
+		}
+
+		if (!\in_array($driverName, self::getDriverList(), true)) {
+			throw new PhpfastcacheLogicException(\sprintf("Driver '%s' can't be overridden since its not a part of the PhpFastCache core", $driverName));
+		}
+
+		if (!\is_subclass_of($className, self::CORE_DRIVER_NAMESPACE . $driverName . '\\Driver', true)) {
+			throw new PhpfastcacheLogicException(
+				\sprintf(
+					"Can't override '%s' because the class '%s' MUST extend '%s'",
+					$driverName,
+					$className,
+					self::CORE_DRIVER_NAMESPACE . $driverName . '\\Driver'
+				)
+			);
+		}
+
+		self::$driverOverrides[$driverName] = $className;
+	}
+
+	/**
+	 * @param string $driverName
+	 * @return void
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public static function removeCoreDriverOverride(string $driverName): void
+	{
+		$driverName = self::standardizeDriverName($driverName);
+
+		if (empty($driverName)) {
+			throw new PhpfastcacheInvalidArgumentException("Can't remove a core driver override because its name is empty");
+		}
+
+		if (!isset(self::$driverOverrides[$driverName])) {
+			throw new PhpfastcacheLogicException(\sprintf("Driver '%s' were not overridden", $driverName));
+		}
+
+		unset(self::$driverOverrides[$driverName]);
+	}
 }