grommunio / grommunio-web

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

Spacing +2 added lines, -2 removed lines

@@ -176,7 +176,7 @@ 
         $config = self::validateConfig($config);
         $driver = self::standardizeDriverName($driver);
 
-        $instanceId = $instanceId ?: md5($driver . \serialize(\array_filter($config->toArray(), static function ($val){
+        $instanceId = $instanceId ?: md5($driver . \serialize(\array_filter($config->toArray(), static function($val) {
             return !\is_callable($val);
         })));
 
@@ -319,7 +319,7 @@ 
         $found = false;
         self::$instances = \array_filter(
             \array_map(
-                static function (ExtendedCacheItemPoolInterface $cachePool) use ($cachePoolInstance, &$found) {
+                static function(ExtendedCacheItemPoolInterface $cachePool) use ($cachePoolInstance, &$found) {
                     if (\spl_object_hash($cachePool) === \spl_object_hash($cachePoolInstance)) {
                         $found = true;
                         return null;

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]);
+	}
 }

Braces +11 added lines, -7 removed lines

@@ -95,8 +95,7 @@ 
     /**
      * CacheManager constructor.
      */
-    final protected function __construct()
-    {
+    final protected function __construct() {
         // The cache manager is not meant to be instantiated
     }
 
@@ -188,10 +187,12 @@ 
                 $configClass = $driverClass::getConfigClass();
                 self::$instances[$instanceId] = new $driverClass(new $configClass($config->toArray()), $instanceId);
                 self::$instances[$instanceId]->setEventManager(EventManager::getInstance());
-            } else {
+            }
+            else {
                 throw new PhpfastcacheDriverNotFoundException(sprintf('The driver "%s" does not exists', $driver));
             }
-        } else {
+        }
+        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.
@@ -216,7 +217,8 @@ 
     {
         if ($config === null) {
             $config = self::getDefaultConfig();
-        } else {
+        }
+        else {
             if (!($config instanceof ConfigurationOption)) {
                 throw new PhpfastcacheInvalidArgumentException(\sprintf('Unsupported config type: %s', \gettype($config)));
             }
@@ -271,10 +273,12 @@ 
     {
         if (!empty(self::$driverCustoms[$driverName])) {
             $driverClass = self::$driverCustoms[$driverName];
-        } else {
+        }
+        else {
             if (!empty(self::$driverOverrides[$driverName])) {
                 $driverClass = self::$driverOverrides[$driverName];
-            } else {
+            }
+            else {
                 $driverClass = self::getNamespacePath() . $driverName . '\Driver';
             }
         }

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Helper/Psr16Adapter.php

Spacing +1 added lines, -1 removed lines

@@ -152,7 +152,7 @@
         }
         try {
             return \array_map(
-                static function (ExtendedCacheItemInterface $item) use ($default) {
+                static function(ExtendedCacheItemInterface $item) use ($default) {
                     return $item->isHit() ? $item->get() : $default;
                 },
                 $this->internalCacheInstance->getItems($keys)

Indentation +206 added lines, -206 removed lines

@@ -23,10 +23,10 @@ 
 use Phpfastcache\Core\Item\ExtendedCacheItemInterface;
 use Phpfastcache\Core\Pool\ExtendedCacheItemPoolInterface;
 use Phpfastcache\Exceptions\{PhpfastcacheDriverCheckException,
-    PhpfastcacheInvalidArgumentException,
-    PhpfastcacheLogicException,
-    PhpfastcacheRootException,
-    PhpfastcacheSimpleCacheException};
+	PhpfastcacheInvalidArgumentException,
+	PhpfastcacheLogicException,
+	PhpfastcacheRootException,
+	PhpfastcacheSimpleCacheException};
 use Psr\SimpleCache\CacheInterface;
 use Traversable;
 
@@ -36,206 +36,206 @@ 
  */
 class Psr16Adapter implements CacheInterface
 {
-    /**
-     * @var ExtendedCacheItemPoolInterface
-     */
-    protected $internalCacheInstance;
-
-    /**
-     * Psr16Adapter constructor.
-     * @param $driver
-     * @param null|ConfigurationOptionInterface $config
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     * @throws \Phpfastcache\Exceptions\PhpfastcacheDriverException
-     * @throws \Phpfastcache\Exceptions\PhpfastcacheDriverNotFoundException
-     * @throws \Phpfastcache\Exceptions\PhpfastcacheInvalidConfigurationException
-     * @throws \ReflectionException
-     */
-    public function __construct($driver, ConfigurationOptionInterface $config = null)
-    {
-        if ($driver instanceof ExtendedCacheItemPoolInterface) {
-            if ($config !== null) {
-                throw new PhpfastcacheLogicException("You can't pass a config parameter along with an non-string '\$driver' parameter.");
-            }
-            $this->internalCacheInstance = $driver;
-        } else {
-            $this->internalCacheInstance = CacheManager::getInstance($driver, $config);
-        }
-    }
-
-    /**
-     * @param string $key
-     * @param mixed|null $default
-     * @return mixed|null
-     * @throws PhpfastcacheSimpleCacheException
-     * @throws \Psr\Cache\InvalidArgumentException
-     */
-    public function get($key, $default = null)
-    {
-        try {
-            $cacheItem = $this->internalCacheInstance->getItem($key);
-            if (!$cacheItem->isExpired() && $cacheItem->get() !== null) {
-                return $cacheItem->get();
-            }
-
-            return $default;
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param string $key
-     * @param mixed $value
-     * @param null|int|DateInterval $ttl
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     * @throws \Psr\Cache\InvalidArgumentException
-     */
-    public function set($key, $value, $ttl = null): bool
-    {
-        try {
-            $cacheItem = $this->internalCacheInstance
-                ->getItem($key)
-                ->set($value);
-            if (\is_int($ttl) && $ttl <= 0) {
-                $cacheItem->expiresAt((new DateTime('@0')));
-            } elseif ($ttl !== null) {
-                $cacheItem->expiresAfter($ttl);
-            }
-            return $this->internalCacheInstance->save($cacheItem);
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param string $key
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     */
-    public function delete($key): bool
-    {
-        try {
-            return $this->internalCacheInstance->deleteItem($key);
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     */
-    public function clear(): bool
-    {
-        try {
-            return $this->internalCacheInstance->clear();
-        } catch (PhpfastcacheRootException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param iterable $keys
-     * @param null $default
-     * @return ExtendedCacheItemInterface[]|iterable
-     * @throws PhpfastcacheSimpleCacheException
-     * @throws \Psr\Cache\InvalidArgumentException
-     */
-    public function getMultiple($keys, $default = null)
-    {
-        if ($keys instanceof Traversable) {
-            $keys = \iterator_to_array($keys);
-        }
-        try {
-            return \array_map(
-                static function (ExtendedCacheItemInterface $item) use ($default) {
-                    return $item->isHit() ? $item->get() : $default;
-                },
-                $this->internalCacheInstance->getItems($keys)
-            );
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param string[] $values
-     * @param null|int|DateInterval $ttl
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     * @throws \Psr\Cache\InvalidArgumentException
-     */
-    public function setMultiple($values, $ttl = null): bool
-    {
-        try {
-            foreach ($values as $key => $value) {
-                $cacheItem = $this->internalCacheInstance->getItem($key)->set($value);
-
-                if (\is_int($ttl) && $ttl <= 0) {
-                    $cacheItem->expiresAt((new DateTime('@0')));
-                } elseif ($ttl !== null) {
-                    $cacheItem->expiresAfter($ttl);
-                }
-                $this->internalCacheInstance->saveDeferred($cacheItem);
-                unset($cacheItem);
-            }
-            return $this->internalCacheInstance->commit();
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param iterable|array $keys
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     * @throws \Psr\Cache\InvalidArgumentException
-     */
-    public function deleteMultiple($keys): bool
-    {
-        try {
-            if ($keys instanceof Traversable) {
-                return $this->internalCacheInstance->deleteItems(\iterator_to_array($keys));
-            } elseif (\is_array($keys)) {
-                return $this->internalCacheInstance->deleteItems($keys);
-            } else {
-                throw new phpFastCacheInvalidArgumentException('$keys must be an array/Traversable instance.');
-            }
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param string $key
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     */
-    public function has($key): bool
-    {
-        try {
-            $cacheItem = $this->internalCacheInstance->getItem($key);
-            return $cacheItem->isHit() && !$cacheItem->isExpired();
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * Extra methods that are not part of
-     * psr16 specifications
-     */
-
-    /**
-     * @return ExtendedCacheItemPoolInterface
-     * @internal
-     */
-    public function getInternalCacheInstance(): ExtendedCacheItemPoolInterface
-    {
-        return $this->internalCacheInstance;
-    }
+	/**
+	 * @var ExtendedCacheItemPoolInterface
+	 */
+	protected $internalCacheInstance;
+
+	/**
+	 * Psr16Adapter constructor.
+	 * @param $driver
+	 * @param null|ConfigurationOptionInterface $config
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 * @throws \Phpfastcache\Exceptions\PhpfastcacheDriverException
+	 * @throws \Phpfastcache\Exceptions\PhpfastcacheDriverNotFoundException
+	 * @throws \Phpfastcache\Exceptions\PhpfastcacheInvalidConfigurationException
+	 * @throws \ReflectionException
+	 */
+	public function __construct($driver, ConfigurationOptionInterface $config = null)
+	{
+		if ($driver instanceof ExtendedCacheItemPoolInterface) {
+			if ($config !== null) {
+				throw new PhpfastcacheLogicException("You can't pass a config parameter along with an non-string '\$driver' parameter.");
+			}
+			$this->internalCacheInstance = $driver;
+		} else {
+			$this->internalCacheInstance = CacheManager::getInstance($driver, $config);
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @param mixed|null $default
+	 * @return mixed|null
+	 * @throws PhpfastcacheSimpleCacheException
+	 * @throws \Psr\Cache\InvalidArgumentException
+	 */
+	public function get($key, $default = null)
+	{
+		try {
+			$cacheItem = $this->internalCacheInstance->getItem($key);
+			if (!$cacheItem->isExpired() && $cacheItem->get() !== null) {
+				return $cacheItem->get();
+			}
+
+			return $default;
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @param mixed $value
+	 * @param null|int|DateInterval $ttl
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 * @throws \Psr\Cache\InvalidArgumentException
+	 */
+	public function set($key, $value, $ttl = null): bool
+	{
+		try {
+			$cacheItem = $this->internalCacheInstance
+				->getItem($key)
+				->set($value);
+			if (\is_int($ttl) && $ttl <= 0) {
+				$cacheItem->expiresAt((new DateTime('@0')));
+			} elseif ($ttl !== null) {
+				$cacheItem->expiresAfter($ttl);
+			}
+			return $this->internalCacheInstance->save($cacheItem);
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 */
+	public function delete($key): bool
+	{
+		try {
+			return $this->internalCacheInstance->deleteItem($key);
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 */
+	public function clear(): bool
+	{
+		try {
+			return $this->internalCacheInstance->clear();
+		} catch (PhpfastcacheRootException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param iterable $keys
+	 * @param null $default
+	 * @return ExtendedCacheItemInterface[]|iterable
+	 * @throws PhpfastcacheSimpleCacheException
+	 * @throws \Psr\Cache\InvalidArgumentException
+	 */
+	public function getMultiple($keys, $default = null)
+	{
+		if ($keys instanceof Traversable) {
+			$keys = \iterator_to_array($keys);
+		}
+		try {
+			return \array_map(
+				static function (ExtendedCacheItemInterface $item) use ($default) {
+					return $item->isHit() ? $item->get() : $default;
+				},
+				$this->internalCacheInstance->getItems($keys)
+			);
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param string[] $values
+	 * @param null|int|DateInterval $ttl
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 * @throws \Psr\Cache\InvalidArgumentException
+	 */
+	public function setMultiple($values, $ttl = null): bool
+	{
+		try {
+			foreach ($values as $key => $value) {
+				$cacheItem = $this->internalCacheInstance->getItem($key)->set($value);
+
+				if (\is_int($ttl) && $ttl <= 0) {
+					$cacheItem->expiresAt((new DateTime('@0')));
+				} elseif ($ttl !== null) {
+					$cacheItem->expiresAfter($ttl);
+				}
+				$this->internalCacheInstance->saveDeferred($cacheItem);
+				unset($cacheItem);
+			}
+			return $this->internalCacheInstance->commit();
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param iterable|array $keys
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 * @throws \Psr\Cache\InvalidArgumentException
+	 */
+	public function deleteMultiple($keys): bool
+	{
+		try {
+			if ($keys instanceof Traversable) {
+				return $this->internalCacheInstance->deleteItems(\iterator_to_array($keys));
+			} elseif (\is_array($keys)) {
+				return $this->internalCacheInstance->deleteItems($keys);
+			} else {
+				throw new phpFastCacheInvalidArgumentException('$keys must be an array/Traversable instance.');
+			}
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 */
+	public function has($key): bool
+	{
+		try {
+			$cacheItem = $this->internalCacheInstance->getItem($key);
+			return $cacheItem->isHit() && !$cacheItem->isExpired();
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * Extra methods that are not part of
+	 * psr16 specifications
+	 */
+
+	/**
+	 * @return ExtendedCacheItemPoolInterface
+	 * @internal
+	 */
+	public function getInternalCacheInstance(): ExtendedCacheItemPoolInterface
+	{
+		return $this->internalCacheInstance;
+	}
 }

Braces +29 added lines, -19 removed lines

@@ -53,14 +53,14 @@ 
      * @throws \Phpfastcache\Exceptions\PhpfastcacheInvalidConfigurationException
      * @throws \ReflectionException
      */
-    public function __construct($driver, ConfigurationOptionInterface $config = null)
-    {
+    public function __construct($driver, ConfigurationOptionInterface $config = null) {
         if ($driver instanceof ExtendedCacheItemPoolInterface) {
             if ($config !== null) {
                 throw new PhpfastcacheLogicException("You can't pass a config parameter along with an non-string '\$driver' parameter.");
             }
             $this->internalCacheInstance = $driver;
-        } else {
+        }
+        else {
             $this->internalCacheInstance = CacheManager::getInstance($driver, $config);
         }
     }
@@ -72,8 +72,7 @@ 
      * @throws PhpfastcacheSimpleCacheException
      * @throws \Psr\Cache\InvalidArgumentException
      */
-    public function get($key, $default = null)
-    {
+    public function get($key, $default = null) {
         try {
             $cacheItem = $this->internalCacheInstance->getItem($key);
             if (!$cacheItem->isExpired() && $cacheItem->get() !== null) {
@@ -81,7 +80,8 @@ 
             }
 
             return $default;
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -102,11 +102,13 @@ 
                 ->set($value);
             if (\is_int($ttl) && $ttl <= 0) {
                 $cacheItem->expiresAt((new DateTime('@0')));
-            } elseif ($ttl !== null) {
+            }
+            elseif ($ttl !== null) {
                 $cacheItem->expiresAfter($ttl);
             }
             return $this->internalCacheInstance->save($cacheItem);
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -120,7 +122,8 @@ 
     {
         try {
             return $this->internalCacheInstance->deleteItem($key);
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -133,7 +136,8 @@ 
     {
         try {
             return $this->internalCacheInstance->clear();
-        } catch (PhpfastcacheRootException $e) {
+        }
+        catch (PhpfastcacheRootException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -145,8 +149,7 @@ 
      * @throws PhpfastcacheSimpleCacheException
      * @throws \Psr\Cache\InvalidArgumentException
      */
-    public function getMultiple($keys, $default = null)
-    {
+    public function getMultiple($keys, $default = null) {
         if ($keys instanceof Traversable) {
             $keys = \iterator_to_array($keys);
         }
@@ -157,7 +160,8 @@ 
                 },
                 $this->internalCacheInstance->getItems($keys)
             );
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -177,14 +181,16 @@ 
 
                 if (\is_int($ttl) && $ttl <= 0) {
                     $cacheItem->expiresAt((new DateTime('@0')));
-                } elseif ($ttl !== null) {
+                }
+                elseif ($ttl !== null) {
                     $cacheItem->expiresAfter($ttl);
                 }
                 $this->internalCacheInstance->saveDeferred($cacheItem);
                 unset($cacheItem);
             }
             return $this->internalCacheInstance->commit();
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -200,12 +206,15 @@ 
         try {
             if ($keys instanceof Traversable) {
                 return $this->internalCacheInstance->deleteItems(\iterator_to_array($keys));
-            } elseif (\is_array($keys)) {
+            }
+            elseif (\is_array($keys)) {
                 return $this->internalCacheInstance->deleteItems($keys);
-            } else {
+            }
+            else {
                 throw new phpFastCacheInvalidArgumentException('$keys must be an array/Traversable instance.');
             }
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -220,7 +229,8 @@ 
         try {
             $cacheItem = $this->internalCacheInstance->getItem($key);
             return $cacheItem->isHit() && !$cacheItem->isExpired();
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }

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

Spacing +3 added lines, -3 removed lines

@@ -30,7 +30,7 @@ 
  * Register Autoload
  */
 spl_autoload_register(
-    static function ($entity): void {
+    static function($entity): void {
         $module = explode('\\', $entity, 2);
         if (!\in_array($module[0], ['Phpfastcache', 'Psr'])) {
             /**
@@ -64,9 +64,9 @@ 
 
         $entityPath = str_replace('\\', '/', $entity);
 
-        if(\strpos($entity, PFC_TESTS_NS) === 0){
+        if (\strpos($entity, PFC_TESTS_NS) === 0) {
             $path = PFC_TESTS_DIR . \str_replace(str_replace('\\', '/', PFC_TESTS_NS), '', $entityPath) . '.' . PFC_PHP_EXT;
-        }else{
+        } else {
             $path = PFC_LIB_DIR . $entityPath . '.' . PFC_PHP_EXT;
         }
 

Indentation +42 added lines, -42 removed lines

@@ -30,56 +30,56 @@
  * Register Autoload
  */
 spl_autoload_register(
-    static function ($entity): void {
-        $module = explode('\\', $entity, 2);
-        if (!\in_array($module[0], ['Phpfastcache', 'Psr'])) {
-            /**
-             * Not a part of phpFastCache file
-             * then we return here.
-             */
-            return;
-        }
+	static function ($entity): void {
+		$module = explode('\\', $entity, 2);
+		if (!\in_array($module[0], ['Phpfastcache', 'Psr'])) {
+			/**
+			 * Not a part of phpFastCache file
+			 * then we return here.
+			 */
+			return;
+		}
 
-        if (\strpos($entity, 'Psr\Cache') === 0) {
-            $path = PFC_BIN_DIR . 'dependencies/Psr/Cache/src/' . substr(strrchr($entity, '\\'), 1) . '.' . PFC_PHP_EXT;
+		if (\strpos($entity, 'Psr\Cache') === 0) {
+			$path = PFC_BIN_DIR . 'dependencies/Psr/Cache/src/' . substr(strrchr($entity, '\\'), 1) . '.' . PFC_PHP_EXT;
 
-            if (\is_readable($path)) {
-                require_once $path;
-            } else {
-                \trigger_error('Cannot locate the Psr/Cache files', E_USER_ERROR);
-            }
-            return;
-        }
+			if (\is_readable($path)) {
+				require_once $path;
+			} else {
+				\trigger_error('Cannot locate the Psr/Cache files', E_USER_ERROR);
+			}
+			return;
+		}
 
-        if (\strpos($entity, 'Psr\SimpleCache') === 0) {
-            $path = PFC_BIN_DIR . 'dependencies/Psr/SimpleCache/src/' . \substr(\strrchr($entity, '\\'), 1) . '.' . PFC_PHP_EXT;
+		if (\strpos($entity, 'Psr\SimpleCache') === 0) {
+			$path = PFC_BIN_DIR . 'dependencies/Psr/SimpleCache/src/' . \substr(\strrchr($entity, '\\'), 1) . '.' . PFC_PHP_EXT;
 
-            if (\is_readable($path)) {
-                require_once $path;
-            } else {
-                \trigger_error('Cannot locate the Psr/SimpleCache files', E_USER_ERROR);
-            }
-            return;
-        }
+			if (\is_readable($path)) {
+				require_once $path;
+			} else {
+				\trigger_error('Cannot locate the Psr/SimpleCache files', E_USER_ERROR);
+			}
+			return;
+		}
 
-        $entityPath = str_replace('\\', '/', $entity);
+		$entityPath = str_replace('\\', '/', $entity);
 
-        if(\strpos($entity, PFC_TESTS_NS) === 0){
-            $path = PFC_TESTS_DIR . \str_replace(str_replace('\\', '/', PFC_TESTS_NS), '', $entityPath) . '.' . PFC_PHP_EXT;
-        }else{
-            $path = PFC_LIB_DIR . $entityPath . '.' . PFC_PHP_EXT;
-        }
+		if(\strpos($entity, PFC_TESTS_NS) === 0){
+			$path = PFC_TESTS_DIR . \str_replace(str_replace('\\', '/', PFC_TESTS_NS), '', $entityPath) . '.' . PFC_PHP_EXT;
+		}else{
+			$path = PFC_LIB_DIR . $entityPath . '.' . PFC_PHP_EXT;
+		}
 
-        $path = \realpath($path);
-        if (\is_readable($path)) {
-            require_once $path;
-        }
-    }
+		$path = \realpath($path);
+		if (\is_readable($path)) {
+			require_once $path;
+		}
+	}
 );
 
 if ((!\defined('PFC_IGNORE_COMPOSER_WARNING') || !PFC_IGNORE_COMPOSER_WARNING) && \class_exists(ClassLoader::class)) {
-    trigger_error(
-        'Your project already makes use of Composer. You SHOULD use the composer dependency "phpfastcache/phpfastcache" instead of hard-autoloading.',
-        E_USER_WARNING
-    );
+	trigger_error(
+		'Your project already makes use of Composer. You SHOULD use the composer dependency "phpfastcache/phpfastcache" instead of hard-autoloading.',
+		E_USER_WARNING
+	);
 }

Braces +6 added lines, -3 removed lines

@@ -45,7 +45,8 @@ 
 
             if (\is_readable($path)) {
                 require_once $path;
-            } else {
+            }
+            else {
                 \trigger_error('Cannot locate the Psr/Cache files', E_USER_ERROR);
             }
             return;
@@ -56,7 +57,8 @@ 
 
             if (\is_readable($path)) {
                 require_once $path;
-            } else {
+            }
+            else {
                 \trigger_error('Cannot locate the Psr/SimpleCache files', E_USER_ERROR);
             }
             return;
@@ -66,7 +68,8 @@ 
 
         if(\strpos($entity, PFC_TESTS_NS) === 0){
             $path = PFC_TESTS_DIR . \str_replace(str_replace('\\', '/', PFC_TESTS_NS), '', $entityPath) . '.' . PFC_PHP_EXT;
-        }else{
+        }
+        else{
             $path = PFC_LIB_DIR . $entityPath . '.' . PFC_PHP_EXT;
         }
 

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Util/Directory.php

Spacing +4 added lines, -5 removed lines

@@ -91,8 +91,7 @@ 
             return unlink($source);
         }
 
-        $files = new RecursiveIteratorIterator
-        (
+        $files = new RecursiveIteratorIterator(
             new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
             RecursiveIteratorIterator::CHILD_FIRST
         );
@@ -102,7 +101,7 @@ 
              * @var SplFileInfo $fileinfo
              */
             $realpath = $fileinfo->getRealPath();
-            if($realpath){
+            if ($realpath) {
                 if ($fileinfo->isDir()) {
                     if (self::rrmdir($fileinfo->getRealPath()) === false) {
                         return false;
@@ -111,7 +110,7 @@ 
                     return false;
                 }
             }
-            else{
+            else {
                 return false;
             }
         }
@@ -148,7 +147,7 @@ 
         /**
          * Allows to dereference char
          */
-        $__FILE__ = preg_replace('~^(([a-z0-9\-]+)://)~', '', __FILE__);// remove file protocols such as "phar://" etc.
+        $__FILE__ = preg_replace('~^(([a-z0-9\-]+)://)~', '', __FILE__); // remove file protocols such as "phar://" etc.
         $prefix = $__FILE__[0] === DIRECTORY_SEPARATOR ? DIRECTORY_SEPARATOR : '';
         return $prefix . implode(DIRECTORY_SEPARATOR, $absolutes);
     }

Indentation +115 added lines, -115 removed lines

@@ -26,130 +26,130 @@
  */
 class Directory
 {
-    /**
-     * Get the directory size
-     * @param string $directory
-     * @param bool $includeDirAllocSize
-     * @return integer
-     */
-    public static function dirSize(string $directory, bool $includeDirAllocSize = false): int
-    {
-        $size = 0;
-        foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory)) as $file) {
-            /**
-             * @var SplFileInfo $file
-             */
-            if ($file->isFile()) {
-                $size += filesize($file->getRealPath());
-            } else {
-                if ($includeDirAllocSize) {
-                    $size += $file->getSize();
-                }
-            }
-        }
+	/**
+	 * Get the directory size
+	 * @param string $directory
+	 * @param bool $includeDirAllocSize
+	 * @return integer
+	 */
+	public static function dirSize(string $directory, bool $includeDirAllocSize = false): int
+	{
+		$size = 0;
+		foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory)) as $file) {
+			/**
+			 * @var SplFileInfo $file
+			 */
+			if ($file->isFile()) {
+				$size += filesize($file->getRealPath());
+			} else {
+				if ($includeDirAllocSize) {
+					$size += $file->getSize();
+				}
+			}
+		}
 
-        return $size;
-    }
+		return $size;
+	}
 
-    /**
-     * @param string $path
-     * @return int
-     */
-    public static function getFileCount(string $path): int
-    {
-        $count = 0;
-        $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST);
-        foreach ($objects as $object) {
-            /**
-             * @var SplFileInfo $object
-             */
-            if ($object->isFile()) {
-                $count++;
-            }
-        }
+	/**
+	 * @param string $path
+	 * @return int
+	 */
+	public static function getFileCount(string $path): int
+	{
+		$count = 0;
+		$objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST);
+		foreach ($objects as $object) {
+			/**
+			 * @var SplFileInfo $object
+			 */
+			if ($object->isFile()) {
+				$count++;
+			}
+		}
 
-        return $count;
-    }
+		return $count;
+	}
 
-    /**
-     * Recursively delete a directory and all of it's contents - e.g.the equivalent of `rm -r` on the command-line.
-     * Consistent with `rmdir()` and `unlink()`, an E_WARNING level error will be generated on failure.
-     *
-     * @param string $source absolute path to directory or file to delete.
-     * @param bool $removeOnlyChildren set to true will only remove content inside directory.
-     *
-     * @return bool true on success; false on failure
-     */
-    public static function rrmdir(string $source, bool $removeOnlyChildren = false): bool
-    {
-        if (empty($source) || file_exists($source) === false) {
-            return false;
-        }
+	/**
+	 * Recursively delete a directory and all of it's contents - e.g.the equivalent of `rm -r` on the command-line.
+	 * Consistent with `rmdir()` and `unlink()`, an E_WARNING level error will be generated on failure.
+	 *
+	 * @param string $source absolute path to directory or file to delete.
+	 * @param bool $removeOnlyChildren set to true will only remove content inside directory.
+	 *
+	 * @return bool true on success; false on failure
+	 */
+	public static function rrmdir(string $source, bool $removeOnlyChildren = false): bool
+	{
+		if (empty($source) || file_exists($source) === false) {
+			return false;
+		}
 
-        if (is_file($source) || is_link($source)) {
-            clearstatcache(true, $source);
-            return unlink($source);
-        }
+		if (is_file($source) || is_link($source)) {
+			clearstatcache(true, $source);
+			return unlink($source);
+		}
 
-        $files = new RecursiveIteratorIterator
-        (
-            new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
-            RecursiveIteratorIterator::CHILD_FIRST
-        );
+		$files = new RecursiveIteratorIterator
+		(
+			new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
+			RecursiveIteratorIterator::CHILD_FIRST
+		);
 
-        foreach ($files as $fileinfo) {
-            /**
-             * @var SplFileInfo $fileinfo
-             */
-            $realpath = $fileinfo->getRealPath();
-            if($realpath){
-                if ($fileinfo->isDir()) {
-                    if (self::rrmdir($fileinfo->getRealPath()) === false) {
-                        return false;
-                    }
-                } elseif (unlink($realpath) === false) {
-                    return false;
-                }
-            }
-            else{
-                return false;
-            }
-        }
+		foreach ($files as $fileinfo) {
+			/**
+			 * @var SplFileInfo $fileinfo
+			 */
+			$realpath = $fileinfo->getRealPath();
+			if($realpath){
+				if ($fileinfo->isDir()) {
+					if (self::rrmdir($fileinfo->getRealPath()) === false) {
+						return false;
+					}
+				} elseif (unlink($realpath) === false) {
+					return false;
+				}
+			}
+			else{
+				return false;
+			}
+		}
 
-        if ($removeOnlyChildren === false) {
-            return rmdir($source);
-        }
+		if ($removeOnlyChildren === false) {
+			return rmdir($source);
+		}
 
-        return true;
-    }
+		return true;
+	}
 
-    /**
-     * Alias of realpath() but work
-     * on non-existing files
-     *
-     * @param string $path
-     * @return string
-     */
-    public static function getAbsolutePath(string $path): string
-    {
-        $parts = preg_split('~[/\\\\]+~', $path, 0, PREG_SPLIT_NO_EMPTY);
-        $absolutes = [];
-        foreach ($parts as $part) {
-            if ('.' === $part) {
-                continue;
-            }
-            if ('..' === $part) {
-                array_pop($absolutes);
-            } else {
-                $absolutes[] = $part;
-            }
-        }
+	/**
+	 * Alias of realpath() but work
+	 * on non-existing files
+	 *
+	 * @param string $path
+	 * @return string
+	 */
+	public static function getAbsolutePath(string $path): string
+	{
+		$parts = preg_split('~[/\\\\]+~', $path, 0, PREG_SPLIT_NO_EMPTY);
+		$absolutes = [];
+		foreach ($parts as $part) {
+			if ('.' === $part) {
+				continue;
+			}
+			if ('..' === $part) {
+				array_pop($absolutes);
+			} else {
+				$absolutes[] = $part;
+			}
+		}
 
-        /**
-         * Allows to dereference char
-         */
-        $__FILE__ = preg_replace('~^(([a-z0-9\-]+)://)~', '', __FILE__);// remove file protocols such as "phar://" etc.
-        $prefix = $__FILE__[0] === DIRECTORY_SEPARATOR ? DIRECTORY_SEPARATOR : '';
-        return $prefix . implode(DIRECTORY_SEPARATOR, $absolutes);
-    }
+		/**
+		 * Allows to dereference char
+		 */
+		$__FILE__ = preg_replace('~^(([a-z0-9\-]+)://)~', '', __FILE__);// remove file protocols such as "phar://" etc.
+		$prefix = $__FILE__[0] === DIRECTORY_SEPARATOR ? DIRECTORY_SEPARATOR : '';
+		return $prefix . implode(DIRECTORY_SEPARATOR, $absolutes);
+	}
 }

Braces +6 added lines, -3 removed lines

@@ -41,7 +41,8 @@ 
              */
             if ($file->isFile()) {
                 $size += filesize($file->getRealPath());
-            } else {
+            }
+            else {
                 if ($includeDirAllocSize) {
                     $size += $file->getSize();
                 }
@@ -107,7 +108,8 @@ 
                     if (self::rrmdir($fileinfo->getRealPath()) === false) {
                         return false;
                     }
-                } elseif (unlink($realpath) === false) {
+                }
+                elseif (unlink($realpath) === false) {
                     return false;
                 }
             }
@@ -140,7 +142,8 @@ 
             }
             if ('..' === $part) {
                 array_pop($absolutes);
-            } else {
+            }
+            else {
                 $absolutes[] = $part;
             }
         }

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Util/ClassNamespaceResolverTrait.php

Spacing +2 added lines, -2 removed lines

@@ -99,14 +99,14 @@
                 case T_NAMESPACE:
                     $namespace = '';
                     // If there is a namespace, extract it (PHP 8 test)
-                    if(\defined('T_NAME_QUALIFIED')){
+                    if (\defined('T_NAME_QUALIFIED')) {
                         while (isset($tokens[++$i][1])) {
                             if ($tokens[$i][0] === T_NAME_QUALIFIED) {
                                 $namespace = $tokens[$i][1];
                                 break;
                             }
                         }
-                    }else{
+                    } else {
                         while (isset($tokens[++$i][1])) {
                             if (\in_array($tokens[$i][0], [T_STRING, T_NS_SEPARATOR], true)) {
                                 $namespace .= $tokens[$i][1];

Indentation +136 added lines, -136 removed lines

@@ -28,148 +28,148 @@
  */
 trait ClassNamespaceResolverTrait
 {
-    /**
-     * @var string
-     */
-    protected $namespace;
+	/**
+	 * @var string
+	 */
+	protected $namespace;
 
-    /**
-     * Iterate over all files in the given directory searching for classes.
-     *
-     * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
-     * deprecated the whole component as of SF4. Our thanks to them.
-     *
-     * @param Iterator|string|array $dir The directory to search in or an iterator
-     *
-     * @return array A class map array
-     */
-    protected static function createClassMap($dir): array
-    {
-        if (\is_string($dir)) {
-            $dir = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));
-        }
-        $map = [];
+	/**
+	 * Iterate over all files in the given directory searching for classes.
+	 *
+	 * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
+	 * deprecated the whole component as of SF4. Our thanks to them.
+	 *
+	 * @param Iterator|string|array $dir The directory to search in or an iterator
+	 *
+	 * @return array A class map array
+	 */
+	protected static function createClassMap($dir): array
+	{
+		if (\is_string($dir)) {
+			$dir = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir));
+		}
+		$map = [];
 
-        if (\is_iterable($dir)) {
-            foreach ($dir as $file) {
-                if (!$file->isFile()) {
-                    continue;
-                }
-                $path = $file->getRealPath() ?: $file->getPathname();
-                if ('php' !== pathinfo($path, PATHINFO_EXTENSION)) {
-                    continue;
-                }
-                $classes = self::findClasses($path);
-                if (PHP_VERSION_ID >= 70000) {
-                    // PHP 7 memory manager will not release after token_get_all(), see https://bugs.php.net/70098
-                    gc_mem_caches();
-                }
-                foreach ($classes as $class) {
-                    $map[$class] = $path;
-                }
-            }
-        }
+		if (\is_iterable($dir)) {
+			foreach ($dir as $file) {
+				if (!$file->isFile()) {
+					continue;
+				}
+				$path = $file->getRealPath() ?: $file->getPathname();
+				if ('php' !== pathinfo($path, PATHINFO_EXTENSION)) {
+					continue;
+				}
+				$classes = self::findClasses($path);
+				if (PHP_VERSION_ID >= 70000) {
+					// PHP 7 memory manager will not release after token_get_all(), see https://bugs.php.net/70098
+					gc_mem_caches();
+				}
+				foreach ($classes as $class) {
+					$map[$class] = $path;
+				}
+			}
+		}
 
-        return $map;
-    }
+		return $map;
+	}
 
-    /**
-     * Extract the classes in the given file.
-     *
-     * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
-     * deprecated the whole component as of SF4. Our thanks to them.
-     *
-     * @param string $path The file to check
-     *
-     * @return array The found classes
-     */
-    protected static function findClasses(string $path): array
-    {
-        $contents = file_get_contents($path);
-        $tokens = token_get_all($contents);
-        $classes = [];
-        $namespace = '';
-        for ($i = 0; isset($tokens[$i]); ++$i) {
-            $token = $tokens[$i];
-            if (!isset($token[1])) {
-                continue;
-            }
-            $class = '';
-            switch ($token[0]) {
-                case T_NAMESPACE:
-                    $namespace = '';
-                    // If there is a namespace, extract it (PHP 8 test)
-                    if(\defined('T_NAME_QUALIFIED')){
-                        while (isset($tokens[++$i][1])) {
-                            if ($tokens[$i][0] === T_NAME_QUALIFIED) {
-                                $namespace = $tokens[$i][1];
-                                break;
-                            }
-                        }
-                    }else{
-                        while (isset($tokens[++$i][1])) {
-                            if (\in_array($tokens[$i][0], [T_STRING, T_NS_SEPARATOR], true)) {
-                                $namespace .= $tokens[$i][1];
-                            }
-                        }
-                    }
-                    $namespace .= '\\';
-                    break;
-                case T_CLASS:
-                case T_INTERFACE:
-                case T_TRAIT:
-                    // Skip usage of ::class constant
-                    $isClassConstant = false;
-                    for ($j = $i - 1; $j > 0; --$j) {
-                        if (!isset($tokens[$j][1])) {
-                            break;
-                        }
-                        if (T_DOUBLE_COLON === $tokens[$j][0]) {
-                            $isClassConstant = true;
-                            break;
-                        } elseif (!\in_array($tokens[$j][0], [T_WHITESPACE, T_DOC_COMMENT, T_COMMENT], false)) {
-                            break;
-                        }
-                    }
-                    if ($isClassConstant) {
-                        break;
-                    }
-                    // Find the classname
-                    while (isset($tokens[++$i][1])) {
-                        $t = $tokens[$i];
-                        if (T_STRING === $t[0]) {
-                            $class .= $t[1];
-                        } elseif ('' !== $class && T_WHITESPACE === $t[0]) {
-                            break;
-                        }
-                    }
-                    $classes[] = ltrim($namespace . $class, '\\');
-                    break;
-                default:
-                    break;
-            }
-        }
+	/**
+	 * Extract the classes in the given file.
+	 *
+	 * NOTICE: This method has been borrowed from Symfony ClassLoader 3.4 since they
+	 * deprecated the whole component as of SF4. Our thanks to them.
+	 *
+	 * @param string $path The file to check
+	 *
+	 * @return array The found classes
+	 */
+	protected static function findClasses(string $path): array
+	{
+		$contents = file_get_contents($path);
+		$tokens = token_get_all($contents);
+		$classes = [];
+		$namespace = '';
+		for ($i = 0; isset($tokens[$i]); ++$i) {
+			$token = $tokens[$i];
+			if (!isset($token[1])) {
+				continue;
+			}
+			$class = '';
+			switch ($token[0]) {
+				case T_NAMESPACE:
+					$namespace = '';
+					// If there is a namespace, extract it (PHP 8 test)
+					if(\defined('T_NAME_QUALIFIED')){
+						while (isset($tokens[++$i][1])) {
+							if ($tokens[$i][0] === T_NAME_QUALIFIED) {
+								$namespace = $tokens[$i][1];
+								break;
+							}
+						}
+					}else{
+						while (isset($tokens[++$i][1])) {
+							if (\in_array($tokens[$i][0], [T_STRING, T_NS_SEPARATOR], true)) {
+								$namespace .= $tokens[$i][1];
+							}
+						}
+					}
+					$namespace .= '\\';
+					break;
+				case T_CLASS:
+				case T_INTERFACE:
+				case T_TRAIT:
+					// Skip usage of ::class constant
+					$isClassConstant = false;
+					for ($j = $i - 1; $j > 0; --$j) {
+						if (!isset($tokens[$j][1])) {
+							break;
+						}
+						if (T_DOUBLE_COLON === $tokens[$j][0]) {
+							$isClassConstant = true;
+							break;
+						} elseif (!\in_array($tokens[$j][0], [T_WHITESPACE, T_DOC_COMMENT, T_COMMENT], false)) {
+							break;
+						}
+					}
+					if ($isClassConstant) {
+						break;
+					}
+					// Find the classname
+					while (isset($tokens[++$i][1])) {
+						$t = $tokens[$i];
+						if (T_STRING === $t[0]) {
+							$class .= $t[1];
+						} elseif ('' !== $class && T_WHITESPACE === $t[0]) {
+							break;
+						}
+					}
+					$classes[] = ltrim($namespace . $class, '\\');
+					break;
+				default:
+					break;
+			}
+		}
 
-        return $classes;
-    }
+		return $classes;
+	}
 
-    /**
-     * @return string
-     */
-    public function getClassNamespace(): string
-    {
-        if (!$this->namespace) {
-            $this->namespace = substr(static::class, 0, strrpos(static::class, '\\'));
-        }
+	/**
+	 * @return string
+	 */
+	public function getClassNamespace(): string
+	{
+		if (!$this->namespace) {
+			$this->namespace = substr(static::class, 0, strrpos(static::class, '\\'));
+		}
 
-        return $this->namespace;
-    }
+		return $this->namespace;
+	}
 
-    /**
-     * @return string
-     */
-    public function getClassName(): string
-    {
-        return static::class;
-    }
+	/**
+	 * @return string
+	 */
+	public function getClassName(): string
+	{
+		return static::class;
+	}
 }

Braces +6 added lines, -3 removed lines

@@ -106,7 +106,8 @@ 
                                 break;
                             }
                         }
-                    }else{
+                    }
+                    else{
                         while (isset($tokens[++$i][1])) {
                             if (\in_array($tokens[$i][0], [T_STRING, T_NS_SEPARATOR], true)) {
                                 $namespace .= $tokens[$i][1];
@@ -127,7 +128,8 @@ 
                         if (T_DOUBLE_COLON === $tokens[$j][0]) {
                             $isClassConstant = true;
                             break;
-                        } elseif (!\in_array($tokens[$j][0], [T_WHITESPACE, T_DOC_COMMENT, T_COMMENT], false)) {
+                        }
+                        elseif (!\in_array($tokens[$j][0], [T_WHITESPACE, T_DOC_COMMENT, T_COMMENT], false)) {
                             break;
                         }
                     }
@@ -139,7 +141,8 @@ 
                         $t = $tokens[$i];
                         if (T_STRING === $t[0]) {
                             $class .= $t[1];
-                        } elseif ('' !== $class && T_WHITESPACE === $t[0]) {
+                        }
+                        elseif ('' !== $class && T_WHITESPACE === $t[0]) {
                             break;
                         }
                     }

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Core/Item/ItemExtendedTrait.php

Spacing +3 added lines, -3 removed lines

@@ -66,7 +66,7 @@ 
         if (\is_string($key)) {
             $this->key = $key;
             $this->driver = $driver;
-            if($driver->getConfig()->isUseStaticItemCaching()){
+            if ($driver->getConfig()->isUseStaticItemCaching()) {
                 $this->driver->setItem($this);
             }
             $this->expirationDate = new DateTime();
@@ -282,7 +282,7 @@ 
             $this->data[] = $data;
         } else {
             if (\is_string($data)) {
-                $this->data .= (string)$data;
+                $this->data .= (string) $data;
             } else {
                 throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
             }
@@ -303,7 +303,7 @@ 
             \array_unshift($this->data, $data);
         } else {
             if (\is_string($data)) {
-                $this->data = (string)$data . $this->data;
+                $this->data = (string) $data . $this->data;
             } else {
                 throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
             }

Indentation +323 added lines, -323 removed lines

@@ -36,333 +36,333 @@
  */
 trait ItemExtendedTrait
 {
-    use ClassNamespaceResolverTrait;
-    use TaggableCacheItemTrait;
+	use ClassNamespaceResolverTrait;
+	use TaggableCacheItemTrait;
 
-    /********************
+	/********************
      *
      * PSR-6 Extended Methods
      *
      *******************/
 
-    /**
-     * @var ExtendedCacheItemPoolInterface
-     */
-    protected $driver;
-
-    /**
-     * @var string
-     */
-    protected $encodedKey;
-
-    /**
-     * Item constructor.
-     * @param ExtendedCacheItemPoolInterface $driver
-     * @param $key
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function __construct(ExtendedCacheItemPoolInterface $driver, $key)
-    {
-        if (\is_string($key)) {
-            $this->key = $key;
-            $this->driver = $driver;
-            if($driver->getConfig()->isUseStaticItemCaching()){
-                $this->driver->setItem($this);
-            }
-            $this->expirationDate = new DateTime();
-            if ($this->driver->getConfig()->isItemDetailedDate()) {
-                $this->creationDate = new DateTime();
-                $this->modificationDate = new DateTime();
-            }
-        } else {
-            throw new PhpfastcacheInvalidArgumentTypeException('string', $key);
-        }
-    }
-
-    /**
-     * @return string
-     */
-    public function getEncodedKey(): string
-    {
-        if (!$this->encodedKey) {
-            $keyHashFunction = $this->driver->getConfig()->getDefaultKeyHashFunction();
-
-            if ($keyHashFunction) {
-                $this->encodedKey = $keyHashFunction($this->getKey());
-            } else {
-                $this->encodedKey = $this->getKey();
-            }
-        }
-
-        return $this->encodedKey;
-    }
-
-    /**
-     * @return DateTimeInterface
-     */
-    public function getExpirationDate(): DateTimeInterface
-    {
-        return $this->expirationDate;
-    }
-
-    /**
-     * Alias of expireAt() with forced $expiration param
-     *
-     * @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 ExtendedCacheItemInterface
-     *   The called object.
-     */
-    public function setExpirationDate(DateTimeInterface $expiration): ExtendedCacheItemInterface
-    {
-        return $this->expiresAt($expiration);
-    }
-
-    /**
-     * @return DateTimeInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function getCreationDate(): DateTimeInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            return $this->creationDate;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    /**
-     * @param DateTimeInterface $date
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function setCreationDate(DateTimeInterface $date): ExtendedCacheItemInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            $this->creationDate = $date;
-            return $this;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    /**
-     * @return DateTimeInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function getModificationDate(): DateTimeInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            return $this->modificationDate;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    /**
-     * @param DateTimeInterface $date
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheLogicException
-     */
-    public function setModificationDate(DateTimeInterface $date): ExtendedCacheItemInterface
-    {
-        if ($this->driver->getConfig()->isItemDetailedDate()) {
-            $this->modificationDate = $date;
-            return $this;
-        }
-
-        throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
-    }
-
-    /**
-     * @return int
-     */
-    public function getTtl(): int
-    {
-        return \max(0, $this->expirationDate->getTimestamp() - \time());
-    }
-
-    /**
-     * @return bool
-     */
-    public function isExpired(): bool
-    {
-        return $this->expirationDate->getTimestamp() < (new DateTime())->getTimestamp();
-    }
-
-    /**
-     * @return bool
-     */
-    public function isNull(): bool
-    {
-        return $this->data === null;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isEmpty(): bool
-    {
-        return empty($this->data);
-    }
-
-    /**
-     * Return the data length:
-     * Either the string length if it's a string (binary mode)
-     * # or the number of element (count) if it's an array
-     * # or the number returned by count() if it's an object implementing \Countable interface
-     * # -1 for anything else
-     * @return int
-     */
-    public function getLength(): int
-    {
-        switch (\gettype($this->data)) {
-            case 'array':
-            case 'object':
-                if (\is_array($this->data) || $this->data instanceof Countable) {
-                    return \count($this->data);
-                }
-                break;
-
-            case 'string':
-                return \strlen($this->data);
-                break;
-        }
-
-        return -1;
-    }
-
-
-    /**
-     * @param int $step
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function increment($step = 1): ExtendedCacheItemInterface
-    {
-        if (\is_int($step)) {
-            $this->fetched = true;
-            $this->data += $step;
-        } else {
-            throw new PhpfastcacheInvalidArgumentException('$step must be numeric.');
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param int $step
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function decrement($step = 1): ExtendedCacheItemInterface
-    {
-        if (\is_int($step)) {
-            $this->fetched = true;
-            $this->data -= $step;
-        } else {
-            throw new PhpfastcacheInvalidArgumentException('$step must be numeric.');
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param array|string $data
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function append($data): ExtendedCacheItemInterface
-    {
-        if (\is_array($this->data)) {
-            $this->data[] = $data;
-        } else {
-            if (\is_string($data)) {
-                $this->data .= (string)$data;
-            } else {
-                throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
-            }
-        }
-
-        return $this;
-    }
-
-
-    /**
-     * @param array|string $data
-     * @return ExtendedCacheItemInterface
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function prepend($data): ExtendedCacheItemInterface
-    {
-        if (\is_array($this->data)) {
-            \array_unshift($this->data, $data);
-        } else {
-            if (\is_string($data)) {
-                $this->data = (string)$data . $this->data;
-            } else {
-                throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
-            }
-        }
-
-        return $this;
-    }
-
-    /**
-     * Return the data as a well-formatted string.
-     * Any scalar value will be casted to an array
-     * @param int $option \json_encode() options
-     * @param int $depth \json_encode() depth
-     * @return string
-     */
-    public function getDataAsJsonString(int $option = 0, int $depth = 512): string
-    {
-        $data = $this->get();
-
-        if (\is_object($data) || \is_array($data)) {
-            $data = \json_encode($data, $option, $depth);
-        } else {
-            $data = \json_encode([$data], $option, $depth);
-        }
-
-        return \json_encode($data, $option, $depth);
-    }
-
-    /**
-     * Implements \JsonSerializable interface
-     * @return mixed
-     */
-    #[\ReturnTypeWillChange] // PHP 8.1 compatibility
-    public function jsonSerialize()
-    {
-        return $this->get();
-    }
-
-    /**
-     * @param ExtendedCacheItemPoolInterface $driverPool
-     * @return bool
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public function doesItemBelongToThatDriverBackend(ExtendedCacheItemPoolInterface $driverPool): bool
-    {
-        return $driverPool->getClassNamespace() === $this->getClassNamespace();
-    }
-
-    /**
-     * @return array
-     * @todo Is it still useful ??
-     *
-     * Prevent recursions for Debug (php 5.6+)
-     */
-    final public function __debugInfo()
-    {
-        $info = \get_object_vars($this);
-        $info['driver'] = 'object(' . \get_class($info['driver']) . ')';
-
-        return $info;
-    }
+	/**
+	 * @var ExtendedCacheItemPoolInterface
+	 */
+	protected $driver;
+
+	/**
+	 * @var string
+	 */
+	protected $encodedKey;
+
+	/**
+	 * Item constructor.
+	 * @param ExtendedCacheItemPoolInterface $driver
+	 * @param $key
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function __construct(ExtendedCacheItemPoolInterface $driver, $key)
+	{
+		if (\is_string($key)) {
+			$this->key = $key;
+			$this->driver = $driver;
+			if($driver->getConfig()->isUseStaticItemCaching()){
+				$this->driver->setItem($this);
+			}
+			$this->expirationDate = new DateTime();
+			if ($this->driver->getConfig()->isItemDetailedDate()) {
+				$this->creationDate = new DateTime();
+				$this->modificationDate = new DateTime();
+			}
+		} else {
+			throw new PhpfastcacheInvalidArgumentTypeException('string', $key);
+		}
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getEncodedKey(): string
+	{
+		if (!$this->encodedKey) {
+			$keyHashFunction = $this->driver->getConfig()->getDefaultKeyHashFunction();
+
+			if ($keyHashFunction) {
+				$this->encodedKey = $keyHashFunction($this->getKey());
+			} else {
+				$this->encodedKey = $this->getKey();
+			}
+		}
+
+		return $this->encodedKey;
+	}
+
+	/**
+	 * @return DateTimeInterface
+	 */
+	public function getExpirationDate(): DateTimeInterface
+	{
+		return $this->expirationDate;
+	}
+
+	/**
+	 * Alias of expireAt() with forced $expiration param
+	 *
+	 * @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 ExtendedCacheItemInterface
+	 *   The called object.
+	 */
+	public function setExpirationDate(DateTimeInterface $expiration): ExtendedCacheItemInterface
+	{
+		return $this->expiresAt($expiration);
+	}
+
+	/**
+	 * @return DateTimeInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getCreationDate(): DateTimeInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			return $this->creationDate;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	/**
+	 * @param DateTimeInterface $date
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setCreationDate(DateTimeInterface $date): ExtendedCacheItemInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			$this->creationDate = $date;
+			return $this;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the creation date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	/**
+	 * @return DateTimeInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getModificationDate(): DateTimeInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			return $this->modificationDate;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	/**
+	 * @param DateTimeInterface $date
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setModificationDate(DateTimeInterface $date): ExtendedCacheItemInterface
+	{
+		if ($this->driver->getConfig()->isItemDetailedDate()) {
+			$this->modificationDate = $date;
+			return $this;
+		}
+
+		throw new PhpfastcacheLogicException('Cannot access to the modification date when the "itemDetailedDate" configuration is disabled.');
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getTtl(): int
+	{
+		return \max(0, $this->expirationDate->getTimestamp() - \time());
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isExpired(): bool
+	{
+		return $this->expirationDate->getTimestamp() < (new DateTime())->getTimestamp();
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isNull(): bool
+	{
+		return $this->data === null;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isEmpty(): bool
+	{
+		return empty($this->data);
+	}
+
+	/**
+	 * Return the data length:
+	 * Either the string length if it's a string (binary mode)
+	 * # or the number of element (count) if it's an array
+	 * # or the number returned by count() if it's an object implementing \Countable interface
+	 * # -1 for anything else
+	 * @return int
+	 */
+	public function getLength(): int
+	{
+		switch (\gettype($this->data)) {
+			case 'array':
+			case 'object':
+				if (\is_array($this->data) || $this->data instanceof Countable) {
+					return \count($this->data);
+				}
+				break;
+
+			case 'string':
+				return \strlen($this->data);
+				break;
+		}
+
+		return -1;
+	}
+
+
+	/**
+	 * @param int $step
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function increment($step = 1): ExtendedCacheItemInterface
+	{
+		if (\is_int($step)) {
+			$this->fetched = true;
+			$this->data += $step;
+		} else {
+			throw new PhpfastcacheInvalidArgumentException('$step must be numeric.');
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param int $step
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function decrement($step = 1): ExtendedCacheItemInterface
+	{
+		if (\is_int($step)) {
+			$this->fetched = true;
+			$this->data -= $step;
+		} else {
+			throw new PhpfastcacheInvalidArgumentException('$step must be numeric.');
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param array|string $data
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function append($data): ExtendedCacheItemInterface
+	{
+		if (\is_array($this->data)) {
+			$this->data[] = $data;
+		} else {
+			if (\is_string($data)) {
+				$this->data .= (string)$data;
+			} else {
+				throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
+			}
+		}
+
+		return $this;
+	}
+
+
+	/**
+	 * @param array|string $data
+	 * @return ExtendedCacheItemInterface
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function prepend($data): ExtendedCacheItemInterface
+	{
+		if (\is_array($this->data)) {
+			\array_unshift($this->data, $data);
+		} else {
+			if (\is_string($data)) {
+				$this->data = (string)$data . $this->data;
+			} else {
+				throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
+			}
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Return the data as a well-formatted string.
+	 * Any scalar value will be casted to an array
+	 * @param int $option \json_encode() options
+	 * @param int $depth \json_encode() depth
+	 * @return string
+	 */
+	public function getDataAsJsonString(int $option = 0, int $depth = 512): string
+	{
+		$data = $this->get();
+
+		if (\is_object($data) || \is_array($data)) {
+			$data = \json_encode($data, $option, $depth);
+		} else {
+			$data = \json_encode([$data], $option, $depth);
+		}
+
+		return \json_encode($data, $option, $depth);
+	}
+
+	/**
+	 * Implements \JsonSerializable interface
+	 * @return mixed
+	 */
+	#[\ReturnTypeWillChange] // PHP 8.1 compatibility
+	public function jsonSerialize()
+	{
+		return $this->get();
+	}
+
+	/**
+	 * @param ExtendedCacheItemPoolInterface $driverPool
+	 * @return bool
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public function doesItemBelongToThatDriverBackend(ExtendedCacheItemPoolInterface $driverPool): bool
+	{
+		return $driverPool->getClassNamespace() === $this->getClassNamespace();
+	}
+
+	/**
+	 * @return array
+	 * @todo Is it still useful ??
+	 *
+	 * Prevent recursions for Debug (php 5.6+)
+	 */
+	final public function __debugInfo()
+	{
+		$info = \get_object_vars($this);
+		$info['driver'] = 'object(' . \get_class($info['driver']) . ')';
+
+		return $info;
+	}
 }

Braces +21 added lines, -15 removed lines

@@ -61,8 +61,7 @@ 
      * @param $key
      * @throws PhpfastcacheInvalidArgumentException
      */
-    public function __construct(ExtendedCacheItemPoolInterface $driver, $key)
-    {
+    public function __construct(ExtendedCacheItemPoolInterface $driver, $key) {
         if (\is_string($key)) {
             $this->key = $key;
             $this->driver = $driver;
@@ -74,7 +73,8 @@ 
                 $this->creationDate = new DateTime();
                 $this->modificationDate = new DateTime();
             }
-        } else {
+        }
+        else {
             throw new PhpfastcacheInvalidArgumentTypeException('string', $key);
         }
     }
@@ -89,7 +89,8 @@ 
 
             if ($keyHashFunction) {
                 $this->encodedKey = $keyHashFunction($this->getKey());
-            } else {
+            }
+            else {
                 $this->encodedKey = $this->getKey();
             }
         }
@@ -247,7 +248,8 @@ 
         if (\is_int($step)) {
             $this->fetched = true;
             $this->data += $step;
-        } else {
+        }
+        else {
             throw new PhpfastcacheInvalidArgumentException('$step must be numeric.');
         }
 
@@ -264,7 +266,8 @@ 
         if (\is_int($step)) {
             $this->fetched = true;
             $this->data -= $step;
-        } else {
+        }
+        else {
             throw new PhpfastcacheInvalidArgumentException('$step must be numeric.');
         }
 
@@ -280,10 +283,12 @@ 
     {
         if (\is_array($this->data)) {
             $this->data[] = $data;
-        } else {
+        }
+        else {
             if (\is_string($data)) {
                 $this->data .= (string)$data;
-            } else {
+            }
+            else {
                 throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
             }
         }
@@ -301,10 +306,12 @@ 
     {
         if (\is_array($this->data)) {
             \array_unshift($this->data, $data);
-        } else {
+        }
+        else {
             if (\is_string($data)) {
                 $this->data = (string)$data . $this->data;
-            } else {
+            }
+            else {
                 throw new PhpfastcacheInvalidArgumentException('$data must be either array nor string.');
             }
         }
@@ -325,7 +332,8 @@ 
 
         if (\is_object($data) || \is_array($data)) {
             $data = \json_encode($data, $option, $depth);
-        } else {
+        }
+        else {
             $data = \json_encode([$data], $option, $depth);
         }
 
@@ -337,8 +345,7 @@ 
      * @return mixed
      */
     #[\ReturnTypeWillChange] // PHP 8.1 compatibility
-    public function jsonSerialize()
-    {
+    public function jsonSerialize() {
         return $this->get();
     }
 
@@ -358,8 +365,7 @@ 
      *
      * Prevent recursions for Debug (php 5.6+)
      */
-    final public function __debugInfo()
-    {
+    final public function __debugInfo() {
         $info = \get_object_vars($this);
         $info['driver'] = 'object(' . \get_class($info['driver']) . ')';
 

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Core/Pool/ExtendedCacheItemPoolTrait.php

Spacing +2 added lines, -2 removed lines

@@ -40,7 +40,7 @@ 
      */
     public function getItemsAsJsonString(array $keys = [], int $option = 0, int $depth = 512): string
     {
-        $callback = static function (CacheItemInterface $item) {
+        $callback = static function(CacheItemInterface $item) {
             return $item->get();
         };
         return \json_encode(\array_map($callback, \array_values($this->getItems($keys))), $option, $depth);
@@ -91,7 +91,7 @@ 
             );
         }
 
-        if(!$this->getConfig()->isUseStaticItemCaching()){
+        if (!$this->getConfig()->isUseStaticItemCaching()) {
             throw new PhpfastcacheLogicException(
                 'The static item caching option (useStaticItemCaching) is disabled so you cannot attach an item.'
             );

Indentation +125 added lines, -125 removed lines

@@ -27,129 +27,129 @@
  */
 trait ExtendedCacheItemPoolTrait
 {
-    use CacheItemPoolTrait;
-    use AbstractDriverPoolTrait;
-
-    /**
-     * @var DriverIO
-     */
-    protected $IO;
-
-    /**
-     * @inheritdoc
-     */
-    public function getItemsAsJsonString(array $keys = [], int $option = 0, int $depth = 512): string
-    {
-        $callback = static function (CacheItemInterface $item) {
-            return $item->get();
-        };
-        return \json_encode(\array_map($callback, \array_values($this->getItems($keys))), $option, $depth);
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function detachAllItems()
-    {
-        foreach ($this->itemInstances as $item) {
-            $this->detachItem($item);
-        }
-    }
-
-    /**
-     * @param CacheItemInterface $item
-     * @return void
-     */
-    public function detachItem(CacheItemInterface $item)
-    {
-        if (isset($this->itemInstances[$item->getKey()])) {
-            $this->deregisterItem($item->getKey());
-        }
-    }
-
-    /**
-     * @param string $item
-     * @internal This method de-register an item from $this->itemInstances
-     */
-    protected function deregisterItem(string $item)
-    {
-        unset($this->itemInstances[$item]);
-
-        if (\gc_enabled()) {
-            \gc_collect_cycles();
-        }
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function attachItem(CacheItemInterface $item)
-    {
-        if (isset($this->itemInstances[$item->getKey()]) && \spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
-            throw new PhpfastcacheLogicException(
-                'The item already exists and cannot be overwritten because the Spl object hash mismatches ! You probably tried to re-attach a detached item which has been already retrieved from cache.'
-            );
-        }
-
-        if(!$this->getConfig()->isUseStaticItemCaching()){
-            throw new PhpfastcacheLogicException(
-                'The static item caching option (useStaticItemCaching) is disabled so you cannot attach an item.'
-            );
-        }
-
-        $this->itemInstances[$item->getKey()] = $item;
-    }
-
-    /**
-     * Returns true if the item exists, is attached and the Spl Hash matches
-     * Returns false if the item exists, is attached and the Spl Hash mismatches
-     * Returns null if the item does not exists
-     *
-     * @param CacheItemInterface $item
-     * @return bool|null
-     */
-    public function isAttached(CacheItemInterface $item)
-    {
-        if (isset($this->itemInstances[$item->getKey()])) {
-            return \spl_object_hash($item) === \spl_object_hash($this->itemInstances[$item->getKey()]);
-        }
-        return null;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function saveMultiple(...$items): bool
-    {
-        if (isset($items[0]) && \is_array($items[0])) {
-            foreach ($items[0] as $item) {
-                $this->save($item);
-            }
-            return true;
-        }
-
-        if (\is_array($items)) {
-            foreach ($items as $item) {
-                $this->save($item);
-            }
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * @return DriverIO
-     */
-    public function getIO(): DriverIO
-    {
-        return $this->IO;
-    }
-
-    /**
-     * @return string
-     */
-    public function getHelp(): string
-    {
-        return '';
-    }
+	use CacheItemPoolTrait;
+	use AbstractDriverPoolTrait;
+
+	/**
+	 * @var DriverIO
+	 */
+	protected $IO;
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getItemsAsJsonString(array $keys = [], int $option = 0, int $depth = 512): string
+	{
+		$callback = static function (CacheItemInterface $item) {
+			return $item->get();
+		};
+		return \json_encode(\array_map($callback, \array_values($this->getItems($keys))), $option, $depth);
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function detachAllItems()
+	{
+		foreach ($this->itemInstances as $item) {
+			$this->detachItem($item);
+		}
+	}
+
+	/**
+	 * @param CacheItemInterface $item
+	 * @return void
+	 */
+	public function detachItem(CacheItemInterface $item)
+	{
+		if (isset($this->itemInstances[$item->getKey()])) {
+			$this->deregisterItem($item->getKey());
+		}
+	}
+
+	/**
+	 * @param string $item
+	 * @internal This method de-register an item from $this->itemInstances
+	 */
+	protected function deregisterItem(string $item)
+	{
+		unset($this->itemInstances[$item]);
+
+		if (\gc_enabled()) {
+			\gc_collect_cycles();
+		}
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function attachItem(CacheItemInterface $item)
+	{
+		if (isset($this->itemInstances[$item->getKey()]) && \spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
+			throw new PhpfastcacheLogicException(
+				'The item already exists and cannot be overwritten because the Spl object hash mismatches ! You probably tried to re-attach a detached item which has been already retrieved from cache.'
+			);
+		}
+
+		if(!$this->getConfig()->isUseStaticItemCaching()){
+			throw new PhpfastcacheLogicException(
+				'The static item caching option (useStaticItemCaching) is disabled so you cannot attach an item.'
+			);
+		}
+
+		$this->itemInstances[$item->getKey()] = $item;
+	}
+
+	/**
+	 * Returns true if the item exists, is attached and the Spl Hash matches
+	 * Returns false if the item exists, is attached and the Spl Hash mismatches
+	 * Returns null if the item does not exists
+	 *
+	 * @param CacheItemInterface $item
+	 * @return bool|null
+	 */
+	public function isAttached(CacheItemInterface $item)
+	{
+		if (isset($this->itemInstances[$item->getKey()])) {
+			return \spl_object_hash($item) === \spl_object_hash($this->itemInstances[$item->getKey()]);
+		}
+		return null;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function saveMultiple(...$items): bool
+	{
+		if (isset($items[0]) && \is_array($items[0])) {
+			foreach ($items[0] as $item) {
+				$this->save($item);
+			}
+			return true;
+		}
+
+		if (\is_array($items)) {
+			foreach ($items as $item) {
+				$this->save($item);
+			}
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @return DriverIO
+	 */
+	public function getIO(): DriverIO
+	{
+		return $this->IO;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getHelp(): string
+	{
+		return '';
+	}
 }

Braces +5 added lines, -10 removed lines

@@ -49,8 +49,7 @@ 
     /**
      * @inheritdoc
      */
-    public function detachAllItems()
-    {
+    public function detachAllItems() {
         foreach ($this->itemInstances as $item) {
             $this->detachItem($item);
         }
@@ -60,8 +59,7 @@ 
      * @param CacheItemInterface $item
      * @return void
      */
-    public function detachItem(CacheItemInterface $item)
-    {
+    public function detachItem(CacheItemInterface $item) {
         if (isset($this->itemInstances[$item->getKey()])) {
             $this->deregisterItem($item->getKey());
         }
@@ -71,8 +69,7 @@ 
      * @param string $item
      * @internal This method de-register an item from $this->itemInstances
      */
-    protected function deregisterItem(string $item)
-    {
+    protected function deregisterItem(string $item) {
         unset($this->itemInstances[$item]);
 
         if (\gc_enabled()) {
@@ -83,8 +80,7 @@ 
     /**
      * @inheritdoc
      */
-    public function attachItem(CacheItemInterface $item)
-    {
+    public function attachItem(CacheItemInterface $item) {
         if (isset($this->itemInstances[$item->getKey()]) && \spl_object_hash($item) !== \spl_object_hash($this->itemInstances[$item->getKey()])) {
             throw new PhpfastcacheLogicException(
                 'The item already exists and cannot be overwritten because the Spl object hash mismatches ! You probably tried to re-attach a detached item which has been already retrieved from cache.'
@@ -108,8 +104,7 @@ 
      * @param CacheItemInterface $item
      * @return bool|null
      */
-    public function isAttached(CacheItemInterface $item)
-    {
+    public function isAttached(CacheItemInterface $item) {
         if (isset($this->itemInstances[$item->getKey()])) {
             return \spl_object_hash($item) === \spl_object_hash($this->itemInstances[$item->getKey()]);
         }

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Core/Pool/TaggableCacheItemPoolTrait.php

Spacing +16 added lines, -16 removed lines

@@ -34,7 +34,7 @@ 
      */
     public function getItemsByTagsAsJsonString(array $tagNames, int $option = 0, int $depth = 512, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): string
     {
-        $callback = static function (CacheItemInterface $item) {
+        $callback = static function(CacheItemInterface $item) {
             return $item->get();
         };
 
@@ -87,7 +87,7 @@ 
         if (\is_string($tagName)) {
             $driverResponse = $this->getItem($this->getTagKey($tagName));
             if ($driverResponse->isHit()) {
-                $tagsItems = (array)$driverResponse->get();
+                $tagsItems = (array) $driverResponse->get();
 
                 /**
                  * getItems() may provides expired item(s)
@@ -101,7 +101,7 @@ 
                  */
                 return \array_filter(
                     $this->getItems(\array_unique(\array_keys($tagsItems))),
-                    static function (ExtendedCacheItemInterface $item) {
+                    static function(ExtendedCacheItemInterface $item) {
                         return $item->isHit();
                     }
                 );
@@ -135,7 +135,7 @@ 
             }
         }
 
-        return (bool)$return;
+        return (bool) $return;
     }
 
     /**
@@ -152,7 +152,7 @@ 
                 }
             }
 
-            return (bool)$return;
+            return (bool) $return;
         }
 
         throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
@@ -187,7 +187,7 @@ 
             }
         }
 
-        return (bool)$return;
+        return (bool) $return;
     }
 
     /**
@@ -201,7 +201,7 @@ 
                 $this->saveDeferred($item);
             }
 
-            return (bool)$this->commit();
+            return (bool) $this->commit();
         }
 
         throw new PhpfastcacheInvalidArgumentException('$tagName must be a string and $step an integer');
@@ -220,7 +220,7 @@ 
             }
         }
 
-        return (bool)$return;
+        return (bool) $return;
     }
 
     /**
@@ -234,7 +234,7 @@ 
                 $this->saveDeferred($item);
             }
 
-            return (bool)$this->commit();
+            return (bool) $this->commit();
         }
 
         throw new PhpfastcacheInvalidArgumentException('$tagName must be a string and $step an integer');
@@ -253,7 +253,7 @@ 
             }
         }
 
-        return (bool)$return;
+        return (bool) $return;
     }
 
     /**
@@ -267,7 +267,7 @@ 
                 $this->saveDeferred($item);
             }
 
-            return (bool)$this->commit();
+            return (bool) $this->commit();
         }
 
         throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
@@ -286,7 +286,7 @@ 
             }
         }
 
-        return (bool)$return;
+        return (bool) $return;
     }
 
     /**
@@ -300,7 +300,7 @@ 
                 $this->saveDeferred($item);
             }
 
-            return (bool)$this->commit();
+            return (bool) $this->commit();
         }
 
         throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
@@ -361,7 +361,7 @@ 
              * that has slow performances
              */
 
-            $tagsItem->set(\array_merge((array)$data, [$item->getKey() => $expTimestamp]))
+            $tagsItem->set(\array_merge((array) $data, [$item->getKey() => $expTimestamp]))
                 ->expiresAt($item->getExpirationDate());
 
             $this->driverWrite($tagsItem);
@@ -375,7 +375,7 @@ 
         $tagsItems = $this->getItems($this->getTagKeys($item->getRemovedTags()));
 
         foreach ($tagsItems as $tagsItem) {
-            $data = (array)$tagsItem->get();
+            $data = (array) $tagsItem->get();
 
             unset($data[$item->getKey()]);
             $tagsItem->set($data);
@@ -406,7 +406,7 @@ 
     protected function getTagKeys(array $keys): array
     {
         return \array_map(
-            function (string $key) {
+            function(string $key) {
                 return $this->getTagKey($key);
             },
             $keys

Indentation +383 added lines, -383 removed lines

@@ -29,387 +29,387 @@
  */
 trait TaggableCacheItemPoolTrait
 {
-    /**
-     * @inheritdoc
-     */
-    public function getItemsByTagsAsJsonString(array $tagNames, int $option = 0, int $depth = 512, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): string
-    {
-        $callback = static function (CacheItemInterface $item) {
-            return $item->get();
-        };
-
-        return \json_encode(\array_map($callback, \array_values($this->getItemsByTags($tagNames, $strategy))), $option, $depth);
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function getItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
-    {
-        $items = [];
-        foreach (\array_unique($tagNames) as $tagName) {
-            if (\is_string($tagName)) {
-                $items[] = $this->fetchItemsByTagFromBackend($tagName);
-            } else {
-                throw new PhpfastcacheInvalidArgumentException('$tagName must be a a string');
-            }
-        }
-
-        $items = \array_merge([], ...$items);
-
-        switch ($strategy) {
-            case TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL:
-                foreach ($items as $key => $item) {
-                    if (\array_diff($tagNames, $item->getTags())) {
-                        unset($items[$key]);
-                    }
-                }
-                break;
-
-            case TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY:
-                foreach ($items as $key => $item) {
-                    if (\array_diff($tagNames, $item->getTags()) || \array_diff($item->getTags(), $tagNames)) {
-                        unset($items[$key]);
-                    }
-                }
-                break;
-        }
-        return $items;
-    }
-
-    /**
-     * @param string $tagName
-     * @return array
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    protected function fetchItemsByTagFromBackend(string $tagName): array
-    {
-        if (\is_string($tagName)) {
-            $driverResponse = $this->getItem($this->getTagKey($tagName));
-            if ($driverResponse->isHit()) {
-                $tagsItems = (array)$driverResponse->get();
-
-                /**
-                 * getItems() may provides expired item(s)
-                 * themselves provided by a cache of item
-                 * keys based stored the tag item.
-                 * Therefore we pass a filter callback
-                 * to remove the expired Item(s) provided by
-                 * the item keys passed through getItems()
-                 *
-                 * #headache
-                 */
-                return \array_filter(
-                    $this->getItems(\array_unique(\array_keys($tagsItems))),
-                    static function (ExtendedCacheItemInterface $item) {
-                        return $item->isHit();
-                    }
-                );
-            }
-            return [];
-        }
-
-        throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
-    }
-
-    /**
-     * @param string $key
-     * @return string
-     */
-    protected function getTagKey(string $key): string
-    {
-        return self::DRIVER_TAGS_KEY_PREFIX . $key;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function deleteItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = null;
-
-        foreach ($this->getItemsByTags($tagNames, $strategy) as $item) {
-            $result = $this->deleteItem($item->getKey());
-            if ($return !== false) {
-                $return = $result;
-            }
-        }
-
-        return (bool)$return;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function deleteItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        if (\is_string($tagName)) {
-            $return = null;
-            foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-                $result = $this->deleteItem($item->getKey());
-                if ($return !== false) {
-                    $return = $result;
-                }
-            }
-
-            return (bool)$return;
-        }
-
-        throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function getItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
-    {
-        $items = $this->fetchItemsByTagFromBackend($tagName);
-        if ($strategy === TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY) {
-            foreach ($items as $key => $item) {
-                if (\array_diff($item->getTags(), $tagName)) {
-                    unset($items[$key]);
-                }
-            }
-        }
-        return $items;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function incrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = null;
-        foreach ($tagNames as $tagName) {
-            $result = $this->incrementItemsByTag($tagName, $step, $strategy);
-            if ($return !== false) {
-                $return = $result;
-            }
-        }
-
-        return (bool)$return;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function incrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        if (\is_string($tagName) && \is_int($step)) {
-            foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-                $item->increment($step);
-                $this->saveDeferred($item);
-            }
-
-            return (bool)$this->commit();
-        }
-
-        throw new PhpfastcacheInvalidArgumentException('$tagName must be a string and $step an integer');
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function decrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = null;
-        foreach ($tagNames as $tagName) {
-            $result = $this->decrementItemsByTag($tagName, $step, $strategy);
-            if ($return !== false) {
-                $return = $result;
-            }
-        }
-
-        return (bool)$return;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function decrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        if (\is_string($tagName) && \is_int($step)) {
-            foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-                $item->decrement($step);
-                $this->saveDeferred($item);
-            }
-
-            return (bool)$this->commit();
-        }
-
-        throw new PhpfastcacheInvalidArgumentException('$tagName must be a string and $step an integer');
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function appendItemsByTags(array $tagNames, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = null;
-        foreach ($tagNames as $tagName) {
-            $result = $this->appendItemsByTag($tagName, $data, $strategy);
-            if ($return !== false) {
-                $return = $result;
-            }
-        }
-
-        return (bool)$return;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function appendItemsByTag(string $tagName, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        if (\is_string($tagName)) {
-            foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-                $item->append($data);
-                $this->saveDeferred($item);
-            }
-
-            return (bool)$this->commit();
-        }
-
-        throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function prependItemsByTags(array $tagNames, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        $return = null;
-        foreach ($tagNames as $tagName) {
-            $result = $this->prependItemsByTag($tagName, $data, $strategy);
-            if ($return !== false) {
-                $return = $result;
-            }
-        }
-
-        return (bool)$return;
-    }
-
-    /**
-     * @inheritdoc
-     */
-    public function prependItemsByTag(string $tagName, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
-    {
-        if (\is_string($tagName)) {
-            foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
-                $item->prepend($data);
-                $this->saveDeferred($item);
-            }
-
-            return (bool)$this->commit();
-        }
-
-        throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
-    }
-
-    /**
-     * @param array $wrapper
-     * @return mixed
-     */
-    protected function driverUnwrapTags(array $wrapper)
-    {
-        return $wrapper[self::DRIVER_TAGS_WRAPPER_INDEX];
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    protected function cleanItemTags(ExtendedCacheItemInterface $item)
-    {
-        $this->driverWriteTags($item->removeTags($item->getTags()));
-    }
-
-    /**
-     * @param ExtendedCacheItemInterface $item
-     * @return bool
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    protected function driverWriteTags(ExtendedCacheItemInterface $item): bool
-    {
-        /**
-         * Do not attempt to write tags
-         * on tags item, it can leads
-         * to an infinite recursive calls
-         */
-        if (\strpos($item->getKey(), self::DRIVER_TAGS_KEY_PREFIX) === 0) {
-            throw new PhpfastcacheLogicException('Trying to set tag(s) to an Tag item index: ' . $item->getKey());
-        }
-
-        if (!$item->getTags() && !$item->getRemovedTags()) {
-            return true;
-        }
-
-        /**
-         * @var $tagsItems ExtendedCacheItemInterface[]
-         */
-        $tagsItems = $this->getItems($this->getTagKeys($item->getTags()));
-
-        foreach ($tagsItems as $tagsItem) {
-            $data = $tagsItem->get();
-            $expTimestamp = $item->getExpirationDate()->getTimestamp();
-
-            /**
-             * Using the key will
-             * avoid to use array_unique
-             * that has slow performances
-             */
-
-            $tagsItem->set(\array_merge((array)$data, [$item->getKey() => $expTimestamp]))
-                ->expiresAt($item->getExpirationDate());
-
-            $this->driverWrite($tagsItem);
-            $tagsItem->setHit(true);
-        }
-
-        /**
-         * Also update removed tags to
-         * keep the index up to date
-         */
-        $tagsItems = $this->getItems($this->getTagKeys($item->getRemovedTags()));
-
-        foreach ($tagsItems as $tagsItem) {
-            $data = (array)$tagsItem->get();
-
-            unset($data[$item->getKey()]);
-            $tagsItem->set($data);
-
-            /**
-             * Recalculate the expiration date
-             *
-             * If the $tagsItem does not have
-             * any cache item references left
-             * then remove it from tagsItems index
-             */
-            if (\count($data)) {
-                $tagsItem->expiresAt((new DateTime())->setTimestamp(max($data)));
-                $this->driverWrite($tagsItem);
-                $tagsItem->setHit(true);
-            } else {
-                $this->deleteItem($tagsItem->getKey());
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * @param array $keys
-     * @return array
-     */
-    protected function getTagKeys(array $keys): array
-    {
-        return \array_map(
-            function (string $key) {
-                return $this->getTagKey($key);
-            },
-            $keys
-        );
-    }
+	/**
+	 * @inheritdoc
+	 */
+	public function getItemsByTagsAsJsonString(array $tagNames, int $option = 0, int $depth = 512, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): string
+	{
+		$callback = static function (CacheItemInterface $item) {
+			return $item->get();
+		};
+
+		return \json_encode(\array_map($callback, \array_values($this->getItemsByTags($tagNames, $strategy))), $option, $depth);
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
+	{
+		$items = [];
+		foreach (\array_unique($tagNames) as $tagName) {
+			if (\is_string($tagName)) {
+				$items[] = $this->fetchItemsByTagFromBackend($tagName);
+			} else {
+				throw new PhpfastcacheInvalidArgumentException('$tagName must be a a string');
+			}
+		}
+
+		$items = \array_merge([], ...$items);
+
+		switch ($strategy) {
+			case TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL:
+				foreach ($items as $key => $item) {
+					if (\array_diff($tagNames, $item->getTags())) {
+						unset($items[$key]);
+					}
+				}
+				break;
+
+			case TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY:
+				foreach ($items as $key => $item) {
+					if (\array_diff($tagNames, $item->getTags()) || \array_diff($item->getTags(), $tagNames)) {
+						unset($items[$key]);
+					}
+				}
+				break;
+		}
+		return $items;
+	}
+
+	/**
+	 * @param string $tagName
+	 * @return array
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	protected function fetchItemsByTagFromBackend(string $tagName): array
+	{
+		if (\is_string($tagName)) {
+			$driverResponse = $this->getItem($this->getTagKey($tagName));
+			if ($driverResponse->isHit()) {
+				$tagsItems = (array)$driverResponse->get();
+
+				/**
+				 * getItems() may provides expired item(s)
+				 * themselves provided by a cache of item
+				 * keys based stored the tag item.
+				 * Therefore we pass a filter callback
+				 * to remove the expired Item(s) provided by
+				 * the item keys passed through getItems()
+				 *
+				 * #headache
+				 */
+				return \array_filter(
+					$this->getItems(\array_unique(\array_keys($tagsItems))),
+					static function (ExtendedCacheItemInterface $item) {
+						return $item->isHit();
+					}
+				);
+			}
+			return [];
+		}
+
+		throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
+	}
+
+	/**
+	 * @param string $key
+	 * @return string
+	 */
+	protected function getTagKey(string $key): string
+	{
+		return self::DRIVER_TAGS_KEY_PREFIX . $key;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function deleteItemsByTags(array $tagNames, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = null;
+
+		foreach ($this->getItemsByTags($tagNames, $strategy) as $item) {
+			$result = $this->deleteItem($item->getKey());
+			if ($return !== false) {
+				$return = $result;
+			}
+		}
+
+		return (bool)$return;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function deleteItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		if (\is_string($tagName)) {
+			$return = null;
+			foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+				$result = $this->deleteItem($item->getKey());
+				if ($return !== false) {
+					$return = $result;
+				}
+			}
+
+			return (bool)$return;
+		}
+
+		throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function getItemsByTag(string $tagName, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): array
+	{
+		$items = $this->fetchItemsByTagFromBackend($tagName);
+		if ($strategy === TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY) {
+			foreach ($items as $key => $item) {
+				if (\array_diff($item->getTags(), $tagName)) {
+					unset($items[$key]);
+				}
+			}
+		}
+		return $items;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function incrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = null;
+		foreach ($tagNames as $tagName) {
+			$result = $this->incrementItemsByTag($tagName, $step, $strategy);
+			if ($return !== false) {
+				$return = $result;
+			}
+		}
+
+		return (bool)$return;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function incrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		if (\is_string($tagName) && \is_int($step)) {
+			foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+				$item->increment($step);
+				$this->saveDeferred($item);
+			}
+
+			return (bool)$this->commit();
+		}
+
+		throw new PhpfastcacheInvalidArgumentException('$tagName must be a string and $step an integer');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function decrementItemsByTags(array $tagNames, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = null;
+		foreach ($tagNames as $tagName) {
+			$result = $this->decrementItemsByTag($tagName, $step, $strategy);
+			if ($return !== false) {
+				$return = $result;
+			}
+		}
+
+		return (bool)$return;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function decrementItemsByTag(string $tagName, int $step = 1, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		if (\is_string($tagName) && \is_int($step)) {
+			foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+				$item->decrement($step);
+				$this->saveDeferred($item);
+			}
+
+			return (bool)$this->commit();
+		}
+
+		throw new PhpfastcacheInvalidArgumentException('$tagName must be a string and $step an integer');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function appendItemsByTags(array $tagNames, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = null;
+		foreach ($tagNames as $tagName) {
+			$result = $this->appendItemsByTag($tagName, $data, $strategy);
+			if ($return !== false) {
+				$return = $result;
+			}
+		}
+
+		return (bool)$return;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function appendItemsByTag(string $tagName, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		if (\is_string($tagName)) {
+			foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+				$item->append($data);
+				$this->saveDeferred($item);
+			}
+
+			return (bool)$this->commit();
+		}
+
+		throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function prependItemsByTags(array $tagNames, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		$return = null;
+		foreach ($tagNames as $tagName) {
+			$result = $this->prependItemsByTag($tagName, $data, $strategy);
+			if ($return !== false) {
+				$return = $result;
+			}
+		}
+
+		return (bool)$return;
+	}
+
+	/**
+	 * @inheritdoc
+	 */
+	public function prependItemsByTag(string $tagName, $data, int $strategy = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE): bool
+	{
+		if (\is_string($tagName)) {
+			foreach ($this->getItemsByTag($tagName, $strategy) as $item) {
+				$item->prepend($data);
+				$this->saveDeferred($item);
+			}
+
+			return (bool)$this->commit();
+		}
+
+		throw new PhpfastcacheInvalidArgumentException('$tagName must be a string');
+	}
+
+	/**
+	 * @param array $wrapper
+	 * @return mixed
+	 */
+	protected function driverUnwrapTags(array $wrapper)
+	{
+		return $wrapper[self::DRIVER_TAGS_WRAPPER_INDEX];
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	protected function cleanItemTags(ExtendedCacheItemInterface $item)
+	{
+		$this->driverWriteTags($item->removeTags($item->getTags()));
+	}
+
+	/**
+	 * @param ExtendedCacheItemInterface $item
+	 * @return bool
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	protected function driverWriteTags(ExtendedCacheItemInterface $item): bool
+	{
+		/**
+		 * Do not attempt to write tags
+		 * on tags item, it can leads
+		 * to an infinite recursive calls
+		 */
+		if (\strpos($item->getKey(), self::DRIVER_TAGS_KEY_PREFIX) === 0) {
+			throw new PhpfastcacheLogicException('Trying to set tag(s) to an Tag item index: ' . $item->getKey());
+		}
+
+		if (!$item->getTags() && !$item->getRemovedTags()) {
+			return true;
+		}
+
+		/**
+		 * @var $tagsItems ExtendedCacheItemInterface[]
+		 */
+		$tagsItems = $this->getItems($this->getTagKeys($item->getTags()));
+
+		foreach ($tagsItems as $tagsItem) {
+			$data = $tagsItem->get();
+			$expTimestamp = $item->getExpirationDate()->getTimestamp();
+
+			/**
+			 * Using the key will
+			 * avoid to use array_unique
+			 * that has slow performances
+			 */
+
+			$tagsItem->set(\array_merge((array)$data, [$item->getKey() => $expTimestamp]))
+				->expiresAt($item->getExpirationDate());
+
+			$this->driverWrite($tagsItem);
+			$tagsItem->setHit(true);
+		}
+
+		/**
+		 * Also update removed tags to
+		 * keep the index up to date
+		 */
+		$tagsItems = $this->getItems($this->getTagKeys($item->getRemovedTags()));
+
+		foreach ($tagsItems as $tagsItem) {
+			$data = (array)$tagsItem->get();
+
+			unset($data[$item->getKey()]);
+			$tagsItem->set($data);
+
+			/**
+			 * Recalculate the expiration date
+			 *
+			 * If the $tagsItem does not have
+			 * any cache item references left
+			 * then remove it from tagsItems index
+			 */
+			if (\count($data)) {
+				$tagsItem->expiresAt((new DateTime())->setTimestamp(max($data)));
+				$this->driverWrite($tagsItem);
+				$tagsItem->setHit(true);
+			} else {
+				$this->deleteItem($tagsItem->getKey());
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * @param array $keys
+	 * @return array
+	 */
+	protected function getTagKeys(array $keys): array
+	{
+		return \array_map(
+			function (string $key) {
+				return $this->getTagKey($key);
+			},
+			$keys
+		);
+	}
 }

Braces +6 added lines, -6 removed lines

@@ -50,7 +50,8 @@ 
         foreach (\array_unique($tagNames) as $tagName) {
             if (\is_string($tagName)) {
                 $items[] = $this->fetchItemsByTagFromBackend($tagName);
-            } else {
+            }
+            else {
                 throw new PhpfastcacheInvalidArgumentException('$tagName must be a a string');
             }
         }
@@ -310,8 +311,7 @@ 
      * @param array $wrapper
      * @return mixed
      */
-    protected function driverUnwrapTags(array $wrapper)
-    {
+    protected function driverUnwrapTags(array $wrapper) {
         return $wrapper[self::DRIVER_TAGS_WRAPPER_INDEX];
     }
 
@@ -320,8 +320,7 @@ 
      * @throws PhpfastcacheInvalidArgumentException
      * @throws PhpfastcacheLogicException
      */
-    protected function cleanItemTags(ExtendedCacheItemInterface $item)
-    {
+    protected function cleanItemTags(ExtendedCacheItemInterface $item) {
         $this->driverWriteTags($item->removeTags($item->getTags()));
     }
 
@@ -391,7 +390,8 @@ 
                 $tagsItem->expiresAt((new DateTime())->setTimestamp(max($data)));
                 $this->driverWrite($tagsItem);
                 $tagsItem->setHit(true);
-            } else {
+            }
+            else {
                 $this->deleteItem($tagsItem->getKey());
             }
         }

plugins/files/php/lib/phpfastcache/lib/Phpfastcache/Core/Pool/IO/IOHelperTrait.php

Spacing +5 added lines, -5 removed lines

@@ -64,9 +64,9 @@ 
             ->setSize(Directory::dirSize($path))
             ->setInfo('Number of files used to build the cache: ' . Directory::getFileCount($path));
 
-        if($this->getConfig()->isUseStaticItemCaching()){
+        if ($this->getConfig()->isUseStaticItemCaching()) {
             $stat->setData(implode(', ', \array_keys($this->itemInstances)));
-        }else{
+        } else {
             $stat->setData('No data available since static item caching option (useStaticItemCaching) is disabled.');
         }
 
@@ -294,7 +294,7 @@ 
             throw new PhpfastcacheIOException("Cannot read file located at: {$file}");
         }
         if (\function_exists('file_get_contents')) {
-            return (string)\file_get_contents($file);
+            return (string) \file_get_contents($file);
         }
 
         $string = '';
@@ -338,7 +338,7 @@ 
                 dirname($file) . \DIRECTORY_SEPARATOR . 'tmp_' . $this->getConfig()->getDefaultFileNameHashFunction()(
                     \bin2hex(\random_bytes(16))
                 )
-            ) . '.' .  $this->getConfig()->getCacheFileExtension() . \random_int(1000, 9999);
+            ) . '.' . $this->getConfig()->getCacheFileExtension() . \random_int(1000, 9999);
 
             $handle = \fopen($tmpFilename, 'w+b');
             if (\is_resource($handle)) {
@@ -359,6 +359,6 @@ 
             }
         }
 
-        return (bool)($octetWritten ?? false);
+        return (bool) ($octetWritten ?? false);
     }
 }

Indentation +310 added lines, -310 removed lines

@@ -37,228 +37,228 @@ 
  */
 trait IOHelperTrait
 {
-    /**
-     * @var array
-     */
-    public $tmp = [];
-
-    /**
-     * Provide a generic getStats() method
-     * for files-based drivers
-     * @return DriverStatistic
-     * @throws PhpfastcacheIOException
-     */
-    public function getStats(): DriverStatistic
-    {
-        $stat = new DriverStatistic();
-        $path = $this->getFilePath(false);
-
-        if (!is_dir($path)) {
-            throw new PhpfastcacheIOException("Can't read PATH:" . $path);
-        }
-        $stat->setRawData(
-                [
-                    'tmp' => $this->tmp,
-                ]
-            )
-            ->setSize(Directory::dirSize($path))
-            ->setInfo('Number of files used to build the cache: ' . Directory::getFileCount($path));
-
-        if($this->getConfig()->isUseStaticItemCaching()){
-            $stat->setData(implode(', ', \array_keys($this->itemInstances)));
-        }else{
-            $stat->setData('No data available since static item caching option (useStaticItemCaching) is disabled.');
-        }
-
-        return $stat;
-    }
-
-    /**
-     * @param $keyword
-     * @param bool $skip
-     * @return string
-     * @throws PhpfastcacheIOException
-     */
-    protected function getFilePath($keyword, $skip = false): string
-    {
-        $path = $this->getPath();
-
-        if ($keyword === false) {
-            return $path;
-        }
-
-        $filename = $this->encodeFilename($keyword);
-        $folder = \substr($filename, 0, 2) . DIRECTORY_SEPARATOR . \substr($filename, 2, 2);
-        $path = \rtrim($path, '/\\') . DIRECTORY_SEPARATOR . $folder;
-
-        /**
-         * Skip Create Sub Folders;
-         */
-        if (!$skip && !\is_dir($path) && @!\mkdir($path, $this->getDefaultChmod(), true) && !\is_dir($path)) {
-            throw new PhpfastcacheIOException(
-                'Path "' . $path . '" is not writable, please set a chmod 0777 or any writable permission and make sure to make use of an absolute path !'
-            );
-        }
-
-        return $path . \DIRECTORY_SEPARATOR . $filename . '.' . $this->getConfig()->getCacheFileExtension();
-    }
-
-    /**
-     * @param bool $readonly
-     * @return string
-     * @throws PhpfastcacheIOException
-     */
-    public function getPath($readonly = false): string
-    {
-        /**
-         * Get the base system temporary directory
-         */
-        $tmp_dir = \rtrim(\ini_get('upload_tmp_dir') ?: \sys_get_temp_dir(), '\\/') . DIRECTORY_SEPARATOR . 'phpfastcache';
-
-        /**
-         * Calculate the security key
-         */
-        {
-            $securityKey = $this->getConfig()->getSecurityKey();
-            if (!$securityKey || \mb_strtolower($securityKey) === 'auto') {
-                if (isset($_SERVER['HTTP_HOST'])) {
-                    $securityKey = \preg_replace('/^www./', '', \strtolower(\str_replace(':', '_', $_SERVER['HTTP_HOST'])));
-                } else {
-                    $securityKey = ($this->isPHPModule() ? 'web' : 'cli');
-                }
-            }
-
-            if ($securityKey !== '') {
-                $securityKey .= '/';
-            }
-
-            $securityKey = static::cleanFileName($securityKey);
-        }
-
-        /**
-         * Extends the temporary directory
-         * with the security key and the driver name
-         */
-        $tmp_dir = \rtrim($tmp_dir, '/') . DIRECTORY_SEPARATOR;
-
-        if (empty($this->getConfig()->getPath())) {
-            $path = $tmp_dir;
-        } else {
-            $path = \rtrim($this->getConfig()->getPath(), '/') . DIRECTORY_SEPARATOR;
-        }
-
-        $path_suffix = $securityKey . DIRECTORY_SEPARATOR . $this->getDriverName();
-        $full_path = Directory::getAbsolutePath($path . $path_suffix);
-        $full_path_tmp = Directory::getAbsolutePath($tmp_dir . $path_suffix);
-        $full_path_hash = $this->getConfig()->getDefaultFileNameHashFunction()($full_path);
-
-        /**
-         * In readonly mode we only attempt
-         * to verify if the directory exists
-         * or not, if it does not then we
-         * return the temp dir
-         */
-        if ($readonly === true) {
-            if ($this->getConfig()->isAutoTmpFallback() && (!@\file_exists($full_path) || !@\is_writable($full_path))) {
-                return $full_path_tmp;
-            }
-            return $full_path;
-        }
-
-        if (!isset($this->tmp[$full_path_hash]) || (!@\file_exists($full_path) || !@\is_writable($full_path))) {
-            if (!@\file_exists($full_path)) {
-                if (@mkdir($full_path, $this->getDefaultChmod(), true) === false && !\is_dir($full_path)) {
-                    throw new PhpfastcacheIOException('The directory ' . $full_path . ' could not be created.');
-                }
-            } else {
-                if (!@\is_writable($full_path)) {
-                    if (!@\chmod($full_path, $this->getDefaultChmod()) && $this->getConfig()->isAutoTmpFallback()) {
-                        /**
-                         * Switch back to tmp dir
-                         * again if the path is not writable
-                         */
-                        $full_path = $full_path_tmp;
-                        if (!@\file_exists($full_path)) {
-                            if (@\mkdir($full_path, $this->getDefaultChmod(), true) && !\is_dir($full_path)) {
-                                throw new PhpfastcacheIOException('The directory ' . $full_path . ' could not be created.');
-                            }
-                        }
-                    }
-                }
-            }
-
-            /**
-             * In case there is no directory
-             * writable including the temporary
-             * one, we must throw an exception
-             */
-            if (!@\file_exists($full_path) || !@\is_writable($full_path)) {
-                throw new PhpfastcacheIOException(
-                    'Path "' . $full_path . '" is not writable, please set a chmod 0777 or any writable permission and make sure to make use of an absolute path !'
-                );
-            }
-
-            $this->tmp[$full_path_hash] = $full_path;
-            $this->htaccessGen($full_path, $this->getConfig()->isValidOption('htaccess') ? $this->getConfig()->getHtaccess() : false);
-        }
-
-        return realpath($full_path);
-    }
-
-    /**
-     * @param $filename
-     * @return string
-     */
-    protected static function cleanFileName($filename): string
-    {
-        $regex = [
-            '/[\?\[\]\/\\\=\<\>\:\;\,\'\"\&\$\#\*\(\)\|\~\`\!\{\}]/',
-            '/\.$/',
-            '/^\./',
-        ];
-        $replace = ['-', '', ''];
-
-        return \trim(\preg_replace($regex, $replace, \trim($filename)), '-');
-    }
-
-    /**
-     * @return int
-     */
-    protected function getDefaultChmod(): int
-    {
-        if (!$this->getConfig()->getDefaultChmod()) {
-            return 0777;
-        }
-
-        return $this->getConfig()->getDefaultChmod();
-    }
-
-    /**
-     * @param $path
-     * @param bool $create
-     * @throws PhpfastcacheIOException
-     */
-    protected function htaccessGen($path, $create = true)
-    {
-        if ($create === true) {
-            if (!\is_writable($path)) {
-                try {
-                    if (!\chmod($path, 0777)) {
-                        throw new PhpfastcacheIOException('Chmod failed on : ' . $path);
-                    }
-                } catch (PhpfastcacheIOException $e) {
-                    throw new PhpfastcacheIOException('PLEASE CHMOD ' . $path . ' - 0777 OR ANY WRITABLE PERMISSION!', 0, $e);
-                }
-            }
-
-            if (!\file_exists($path . '/.htaccess')) {
-                $file = @\fopen($path . '/.htaccess', 'w+b');
-                if (!$file) {
-                    throw new PhpfastcacheIOException('PLEASE CHMOD ' . $path . ' - 0777 OR ANY WRITABLE PERMISSION!');
-                }
-                \fwrite(
-                    $file,
-                    <<<HTACCESS
+	/**
+	 * @var array
+	 */
+	public $tmp = [];
+
+	/**
+	 * Provide a generic getStats() method
+	 * for files-based drivers
+	 * @return DriverStatistic
+	 * @throws PhpfastcacheIOException
+	 */
+	public function getStats(): DriverStatistic
+	{
+		$stat = new DriverStatistic();
+		$path = $this->getFilePath(false);
+
+		if (!is_dir($path)) {
+			throw new PhpfastcacheIOException("Can't read PATH:" . $path);
+		}
+		$stat->setRawData(
+				[
+					'tmp' => $this->tmp,
+				]
+			)
+			->setSize(Directory::dirSize($path))
+			->setInfo('Number of files used to build the cache: ' . Directory::getFileCount($path));
+
+		if($this->getConfig()->isUseStaticItemCaching()){
+			$stat->setData(implode(', ', \array_keys($this->itemInstances)));
+		}else{
+			$stat->setData('No data available since static item caching option (useStaticItemCaching) is disabled.');
+		}
+
+		return $stat;
+	}
+
+	/**
+	 * @param $keyword
+	 * @param bool $skip
+	 * @return string
+	 * @throws PhpfastcacheIOException
+	 */
+	protected function getFilePath($keyword, $skip = false): string
+	{
+		$path = $this->getPath();
+
+		if ($keyword === false) {
+			return $path;
+		}
+
+		$filename = $this->encodeFilename($keyword);
+		$folder = \substr($filename, 0, 2) . DIRECTORY_SEPARATOR . \substr($filename, 2, 2);
+		$path = \rtrim($path, '/\\') . DIRECTORY_SEPARATOR . $folder;
+
+		/**
+		 * Skip Create Sub Folders;
+		 */
+		if (!$skip && !\is_dir($path) && @!\mkdir($path, $this->getDefaultChmod(), true) && !\is_dir($path)) {
+			throw new PhpfastcacheIOException(
+				'Path "' . $path . '" is not writable, please set a chmod 0777 or any writable permission and make sure to make use of an absolute path !'
+			);
+		}
+
+		return $path . \DIRECTORY_SEPARATOR . $filename . '.' . $this->getConfig()->getCacheFileExtension();
+	}
+
+	/**
+	 * @param bool $readonly
+	 * @return string
+	 * @throws PhpfastcacheIOException
+	 */
+	public function getPath($readonly = false): string
+	{
+		/**
+		 * Get the base system temporary directory
+		 */
+		$tmp_dir = \rtrim(\ini_get('upload_tmp_dir') ?: \sys_get_temp_dir(), '\\/') . DIRECTORY_SEPARATOR . 'phpfastcache';
+
+		/**
+		 * Calculate the security key
+		 */
+		{
+			$securityKey = $this->getConfig()->getSecurityKey();
+			if (!$securityKey || \mb_strtolower($securityKey) === 'auto') {
+				if (isset($_SERVER['HTTP_HOST'])) {
+					$securityKey = \preg_replace('/^www./', '', \strtolower(\str_replace(':', '_', $_SERVER['HTTP_HOST'])));
+				} else {
+					$securityKey = ($this->isPHPModule() ? 'web' : 'cli');
+				}
+			}
+
+			if ($securityKey !== '') {
+				$securityKey .= '/';
+			}
+
+			$securityKey = static::cleanFileName($securityKey);
+		}
+
+		/**
+		 * Extends the temporary directory
+		 * with the security key and the driver name
+		 */
+		$tmp_dir = \rtrim($tmp_dir, '/') . DIRECTORY_SEPARATOR;
+
+		if (empty($this->getConfig()->getPath())) {
+			$path = $tmp_dir;
+		} else {
+			$path = \rtrim($this->getConfig()->getPath(), '/') . DIRECTORY_SEPARATOR;
+		}
+
+		$path_suffix = $securityKey . DIRECTORY_SEPARATOR . $this->getDriverName();
+		$full_path = Directory::getAbsolutePath($path . $path_suffix);
+		$full_path_tmp = Directory::getAbsolutePath($tmp_dir . $path_suffix);
+		$full_path_hash = $this->getConfig()->getDefaultFileNameHashFunction()($full_path);
+
+		/**
+		 * In readonly mode we only attempt
+		 * to verify if the directory exists
+		 * or not, if it does not then we
+		 * return the temp dir
+		 */
+		if ($readonly === true) {
+			if ($this->getConfig()->isAutoTmpFallback() && (!@\file_exists($full_path) || !@\is_writable($full_path))) {
+				return $full_path_tmp;
+			}
+			return $full_path;
+		}
+
+		if (!isset($this->tmp[$full_path_hash]) || (!@\file_exists($full_path) || !@\is_writable($full_path))) {
+			if (!@\file_exists($full_path)) {
+				if (@mkdir($full_path, $this->getDefaultChmod(), true) === false && !\is_dir($full_path)) {
+					throw new PhpfastcacheIOException('The directory ' . $full_path . ' could not be created.');
+				}
+			} else {
+				if (!@\is_writable($full_path)) {
+					if (!@\chmod($full_path, $this->getDefaultChmod()) && $this->getConfig()->isAutoTmpFallback()) {
+						/**
+						 * Switch back to tmp dir
+						 * again if the path is not writable
+						 */
+						$full_path = $full_path_tmp;
+						if (!@\file_exists($full_path)) {
+							if (@\mkdir($full_path, $this->getDefaultChmod(), true) && !\is_dir($full_path)) {
+								throw new PhpfastcacheIOException('The directory ' . $full_path . ' could not be created.');
+							}
+						}
+					}
+				}
+			}
+
+			/**
+			 * In case there is no directory
+			 * writable including the temporary
+			 * one, we must throw an exception
+			 */
+			if (!@\file_exists($full_path) || !@\is_writable($full_path)) {
+				throw new PhpfastcacheIOException(
+					'Path "' . $full_path . '" is not writable, please set a chmod 0777 or any writable permission and make sure to make use of an absolute path !'
+				);
+			}
+
+			$this->tmp[$full_path_hash] = $full_path;
+			$this->htaccessGen($full_path, $this->getConfig()->isValidOption('htaccess') ? $this->getConfig()->getHtaccess() : false);
+		}
+
+		return realpath($full_path);
+	}
+
+	/**
+	 * @param $filename
+	 * @return string
+	 */
+	protected static function cleanFileName($filename): string
+	{
+		$regex = [
+			'/[\?\[\]\/\\\=\<\>\:\;\,\'\"\&\$\#\*\(\)\|\~\`\!\{\}]/',
+			'/\.$/',
+			'/^\./',
+		];
+		$replace = ['-', '', ''];
+
+		return \trim(\preg_replace($regex, $replace, \trim($filename)), '-');
+	}
+
+	/**
+	 * @return int
+	 */
+	protected function getDefaultChmod(): int
+	{
+		if (!$this->getConfig()->getDefaultChmod()) {
+			return 0777;
+		}
+
+		return $this->getConfig()->getDefaultChmod();
+	}
+
+	/**
+	 * @param $path
+	 * @param bool $create
+	 * @throws PhpfastcacheIOException
+	 */
+	protected function htaccessGen($path, $create = true)
+	{
+		if ($create === true) {
+			if (!\is_writable($path)) {
+				try {
+					if (!\chmod($path, 0777)) {
+						throw new PhpfastcacheIOException('Chmod failed on : ' . $path);
+					}
+				} catch (PhpfastcacheIOException $e) {
+					throw new PhpfastcacheIOException('PLEASE CHMOD ' . $path . ' - 0777 OR ANY WRITABLE PERMISSION!', 0, $e);
+				}
+			}
+
+			if (!\file_exists($path . '/.htaccess')) {
+				$file = @\fopen($path . '/.htaccess', 'w+b');
+				if (!$file) {
+					throw new PhpfastcacheIOException('PLEASE CHMOD ' . $path . ' - 0777 OR ANY WRITABLE PERMISSION!');
+				}
+				\fwrite(
+					$file,
+					<<<HTACCESS
 ### This .htaccess is auto-generated by PhpFastCache ###
 <IfModule mod_authz_host>
 Require all denied
@@ -268,97 +268,97 @@ 
 Deny from all
 </IfModule>
 HTACCESS
-                );
-                \fclose($file);
-            }
-        }
-    }
-
-    /**
-     * @param $keyword
-     * @return string
-     */
-    protected function encodeFilename($keyword): string
-    {
-        return $this->getConfig()->getDefaultFileNameHashFunction()($keyword);
-    }
-
-    /**
-     * @param $file
-     * @return string
-     * @throws PhpfastcacheIOException
-     */
-    protected function readFile($file): string
-    {
-        if (!\is_readable($file)) {
-            throw new PhpfastcacheIOException("Cannot read file located at: {$file}");
-        }
-        if (\function_exists('file_get_contents')) {
-            return (string)\file_get_contents($file);
-        }
-
-        $string = '';
-
-        $file_handle = @\fopen($file, 'rb');
-        while (!\feof($file_handle)) {
-            $line = \fgets($file_handle);
-            $string .= $line;
-        }
-        \fclose($file_handle);
-
-        return $string;
-    }
-
-    /********************
+				);
+				\fclose($file);
+			}
+		}
+	}
+
+	/**
+	 * @param $keyword
+	 * @return string
+	 */
+	protected function encodeFilename($keyword): string
+	{
+		return $this->getConfig()->getDefaultFileNameHashFunction()($keyword);
+	}
+
+	/**
+	 * @param $file
+	 * @return string
+	 * @throws PhpfastcacheIOException
+	 */
+	protected function readFile($file): string
+	{
+		if (!\is_readable($file)) {
+			throw new PhpfastcacheIOException("Cannot read file located at: {$file}");
+		}
+		if (\function_exists('file_get_contents')) {
+			return (string)\file_get_contents($file);
+		}
+
+		$string = '';
+
+		$file_handle = @\fopen($file, 'rb');
+		while (!\feof($file_handle)) {
+			$line = \fgets($file_handle);
+			$string .= $line;
+		}
+		\fclose($file_handle);
+
+		return $string;
+	}
+
+	/********************
      *
      * PSR-6 Extended Methods
      *
      *******************/
 
-    /**
-     * @param string $file
-     * @param string $data
-     * @param bool $secureFileManipulation
-     * @return bool
-     * @throws PhpfastcacheIOException
-     */
-    protected function writefile(string $file, string $data, bool $secureFileManipulation = false): bool
-    {
-        /**
-         * @eventName CacheWriteFileOnDisk
-         * @param ExtendedCacheItemPoolInterface $this
-         * @param string $file
-         * @param bool $secureFileManipulation
-         *
-         */
-        $this->eventManager->dispatch('CacheWriteFileOnDisk', $this, $file, $secureFileManipulation);
-
-        if ($secureFileManipulation) {
-            $tmpFilename = Directory::getAbsolutePath(
-                dirname($file) . \DIRECTORY_SEPARATOR . 'tmp_' . $this->getConfig()->getDefaultFileNameHashFunction()(
-                    \bin2hex(\random_bytes(16))
-                )
-            ) . '.' .  $this->getConfig()->getCacheFileExtension() . \random_int(1000, 9999);
-
-            $handle = \fopen($tmpFilename, 'w+b');
-            if (\is_resource($handle)) {
-                \flock($handle, \LOCK_EX);
-                $octetWritten = fwrite($handle, $data);
-                \flock($handle, \LOCK_UN);
-                \fclose($handle);
-            }
-
-            if (!\rename($tmpFilename, $file)) {
-                throw new PhpfastcacheIOException(\sprintf('Failed to rename %s to %s', $tmpFilename, $file));
-            }
-        } else {
-            $handle = \fopen($file, 'w+b');
-            if (\is_resource($handle)) {
-                $octetWritten = \fwrite($handle, $data);
-                \fclose($handle);
-            }
-        }
-
-        return (bool)($octetWritten ?? false);
-    }
+	/**
+	 * @param string $file
+	 * @param string $data
+	 * @param bool $secureFileManipulation
+	 * @return bool
+	 * @throws PhpfastcacheIOException
+	 */
+	protected function writefile(string $file, string $data, bool $secureFileManipulation = false): bool
+	{
+		/**
+		 * @eventName CacheWriteFileOnDisk
+		 * @param ExtendedCacheItemPoolInterface $this
+		 * @param string $file
+		 * @param bool $secureFileManipulation
+		 *
+		 */
+		$this->eventManager->dispatch('CacheWriteFileOnDisk', $this, $file, $secureFileManipulation);
+
+		if ($secureFileManipulation) {
+			$tmpFilename = Directory::getAbsolutePath(
+				dirname($file) . \DIRECTORY_SEPARATOR . 'tmp_' . $this->getConfig()->getDefaultFileNameHashFunction()(
+					\bin2hex(\random_bytes(16))
+				)
+			) . '.' .  $this->getConfig()->getCacheFileExtension() . \random_int(1000, 9999);
+
+			$handle = \fopen($tmpFilename, 'w+b');
+			if (\is_resource($handle)) {
+				\flock($handle, \LOCK_EX);
+				$octetWritten = fwrite($handle, $data);
+				\flock($handle, \LOCK_UN);
+				\fclose($handle);
+			}
+
+			if (!\rename($tmpFilename, $file)) {
+				throw new PhpfastcacheIOException(\sprintf('Failed to rename %s to %s', $tmpFilename, $file));
+			}
+		} else {
+			$handle = \fopen($file, 'w+b');
+			if (\is_resource($handle)) {
+				$octetWritten = \fwrite($handle, $data);
+				\fclose($handle);
+			}
+		}
+
+		return (bool)($octetWritten ?? false);
+	}
 }

Braces +13 added lines, -8 removed lines

@@ -66,7 +66,8 @@ 
 
         if($this->getConfig()->isUseStaticItemCaching()){
             $stat->setData(implode(', ', \array_keys($this->itemInstances)));
-        }else{
+        }
+        else{
             $stat->setData('No data available since static item caching option (useStaticItemCaching) is disabled.');
         }
 
@@ -123,7 +124,8 @@ 
             if (!$securityKey || \mb_strtolower($securityKey) === 'auto') {
                 if (isset($_SERVER['HTTP_HOST'])) {
                     $securityKey = \preg_replace('/^www./', '', \strtolower(\str_replace(':', '_', $_SERVER['HTTP_HOST'])));
-                } else {
+                }
+                else {
                     $securityKey = ($this->isPHPModule() ? 'web' : 'cli');
                 }
             }
@@ -143,7 +145,8 @@ 
 
         if (empty($this->getConfig()->getPath())) {
             $path = $tmp_dir;
-        } else {
+        }
+        else {
             $path = \rtrim($this->getConfig()->getPath(), '/') . DIRECTORY_SEPARATOR;
         }
 
@@ -170,7 +173,8 @@ 
                 if (@mkdir($full_path, $this->getDefaultChmod(), true) === false && !\is_dir($full_path)) {
                     throw new PhpfastcacheIOException('The directory ' . $full_path . ' could not be created.');
                 }
-            } else {
+            }
+            else {
                 if (!@\is_writable($full_path)) {
                     if (!@\chmod($full_path, $this->getDefaultChmod()) && $this->getConfig()->isAutoTmpFallback()) {
                         /**
@@ -238,15 +242,15 @@ 
      * @param bool $create
      * @throws PhpfastcacheIOException
      */
-    protected function htaccessGen($path, $create = true)
-    {
+    protected function htaccessGen($path, $create = true) {
         if ($create === true) {
             if (!\is_writable($path)) {
                 try {
                     if (!\chmod($path, 0777)) {
                         throw new PhpfastcacheIOException('Chmod failed on : ' . $path);
                     }
-                } catch (PhpfastcacheIOException $e) {
+                }
+                catch (PhpfastcacheIOException $e) {
                     throw new PhpfastcacheIOException('PLEASE CHMOD ' . $path . ' - 0777 OR ANY WRITABLE PERMISSION!', 0, $e);
                 }
             }
@@ -351,7 +355,8 @@ 
             if (!\rename($tmpFilename, $file)) {
                 throw new PhpfastcacheIOException(\sprintf('Failed to rename %s to %s', $tmpFilename, $file));
             }
-        } else {
+        }
+        else {
             $handle = \fopen($file, 'w+b');
             if (\is_resource($handle)) {
                 $octetWritten = \fwrite($handle, $data);