grommunio / grommunio-web

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Event/EventInterface.php

Indentation +4 added lines, -4 removed lines

@@ -18,8 +18,8 @@
 
 interface EventInterface
 {
-    /**
-     * @return array<string, string>
-     */
-    public static function getEvents(): array;
+	/**
+	 * @return array<string, string>
+	 */
+	public static function getEvents(): array;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Proxy/PhpfastcacheAbstractProxyInterface.php

Indentation +18 added lines, -18 removed lines

@@ -65,24 +65,24 @@
  */
 interface PhpfastcacheAbstractProxyInterface
 {
-    public const DRIVER_CHECK_FAILURE = ExtendedCacheItemPoolInterface::DRIVER_CHECK_FAILURE;
-    public const DRIVER_CONNECT_FAILURE = ExtendedCacheItemPoolInterface::DRIVER_CONNECT_FAILURE;
-    public const DRIVER_KEY_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_KEY_WRAPPER_INDEX;
-    public const DRIVER_DATA_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX;
-    public const DRIVER_EDATE_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX;
-    public const DRIVER_CDATE_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX;
-    public const DRIVER_MDATE_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX;
+	public const DRIVER_CHECK_FAILURE = ExtendedCacheItemPoolInterface::DRIVER_CHECK_FAILURE;
+	public const DRIVER_CONNECT_FAILURE = ExtendedCacheItemPoolInterface::DRIVER_CONNECT_FAILURE;
+	public const DRIVER_KEY_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_KEY_WRAPPER_INDEX;
+	public const DRIVER_DATA_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_DATA_WRAPPER_INDEX;
+	public const DRIVER_EDATE_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_EDATE_WRAPPER_INDEX;
+	public const DRIVER_CDATE_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_CDATE_WRAPPER_INDEX;
+	public const DRIVER_MDATE_WRAPPER_INDEX = ExtendedCacheItemPoolInterface::DRIVER_MDATE_WRAPPER_INDEX;
 
-    public const DRIVER_TAGS_KEY_PREFIX = TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX;
-    public const DRIVER_TAGS_WRAPPER_INDEX = TaggableCacheItemPoolInterface::DRIVER_TAGS_WRAPPER_INDEX;
-    public const TAG_STRATEGY_ONE = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE;
-    public const TAG_STRATEGY_ALL = TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL;
-    public const TAG_STRATEGY_ONLY = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY;
+	public const DRIVER_TAGS_KEY_PREFIX = TaggableCacheItemPoolInterface::DRIVER_TAGS_KEY_PREFIX;
+	public const DRIVER_TAGS_WRAPPER_INDEX = TaggableCacheItemPoolInterface::DRIVER_TAGS_WRAPPER_INDEX;
+	public const TAG_STRATEGY_ONE = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONE;
+	public const TAG_STRATEGY_ALL = TaggableCacheItemPoolInterface::TAG_STRATEGY_ALL;
+	public const TAG_STRATEGY_ONLY = TaggableCacheItemPoolInterface::TAG_STRATEGY_ONLY;
 
-    /**
-     * @param string $name
-     * @param array<mixed> $args
-     * @return mixed
-     */
-    public function __call(string $name, array $args): mixed;
+	/**
+	 * @param string $name
+	 * @param array<mixed> $args
+	 * @return mixed
+	 */
+	public function __call(string $name, array $args): mixed;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Proxy/PhpfastcacheAbstractProxy.php

Indentation +24 added lines, -24 removed lines

@@ -32,30 +32,30 @@
  */
 abstract class PhpfastcacheAbstractProxy implements PhpfastcacheAbstractProxyInterface
 {
-    /**
-     * @var ExtendedCacheItemPoolInterface
-     */
-    protected ExtendedCacheItemPoolInterface $instance;
+	/**
+	 * @var ExtendedCacheItemPoolInterface
+	 */
+	protected ExtendedCacheItemPoolInterface $instance;
 
-    /**
-     * PhpfastcacheAbstractProxy constructor.
-     * @param string $driver
-     * @param null|ConfigurationOptionInterface $config
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheDriverNotFoundException
-     * @throws PhpfastcacheLogicException
-     */
-    public function __construct(string $driver, ?ConfigurationOptionInterface $config = null)
-    {
-        $this->instance = CacheManager::getInstance($driver, $config);
-    }
+	/**
+	 * PhpfastcacheAbstractProxy constructor.
+	 * @param string $driver
+	 * @param null|ConfigurationOptionInterface $config
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheDriverNotFoundException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function __construct(string $driver, ?ConfigurationOptionInterface $config = null)
+	{
+		$this->instance = CacheManager::getInstance($driver, $config);
+	}
 
-    /**
-     * @inheritDoc
-     */
-    public function __call(string $name, array $args): mixed
-    {
-        return $this->instance->$name(...$args);
-    }
+	/**
+	 * @inheritDoc
+	 */
+	public function __call(string $name, array $args): mixed
+	{
+		return $this->instance->$name(...$args);
+	}
 }

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

Indentation +406 added lines, -406 removed lines

@@ -36,410 +36,410 @@
  */
 class CacheManager
 {
-    use ClassNamespaceResolverTrait;
-    use UninstanciableObjectTrait;
-
-    public const CORE_DRIVER_NAMESPACE = 'Phpfastcache\Drivers\\';
-
-    protected static ConfigurationOptionInterface $config;
-
-    protected static string $namespacePath;
-
-    /**
-     * @var ExtendedCacheItemPoolInterface[]
-     */
-    protected static array $instances = [];
-
-    /**
-     * @var string[]
-     */
-    protected static array $driverOverrides = [];
-
-    /**
-     * @var string[]
-     */
-    protected static array $driverCustoms = [];
-
-    /**
-     * @var string[]
-     */
-    protected static array $driverExtensions = [];
-
-    /**
-     * @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;
-    }
-
-    /**
-     * @param string $driver
-     * @param ConfigurationOptionInterface|null $config
-     * @param string|null $instanceId
-     * @return ExtendedCacheItemPoolInterface
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheDriverNotFoundException
-     * @throws PhpfastcacheExtensionNotInstalledException
-     * @throws PhpfastcacheLogicException
-     */
-    public static function getInstance(string $driver, ?ConfigurationOptionInterface $config = null, ?string $instanceId = null): ExtendedCacheItemPoolInterface
-    {
-        if (\class_exists($driver) && \str_starts_with($driver, 'Phpfastcache')) {
-            $driverClass = $driver;
-        } else {
-            $driver = self::normalizeDriverName($driver);
-            $driverClass = self::getDriverClass($driver);
-        }
-        $config = self::validateConfig($config);
-        $instanceId = $instanceId ?: self::getInstanceHash($driverClass, $config);
-
-        if (!isset(self::$instances[$instanceId])) {
-            if (\is_a($driverClass, ExtendedCacheItemPoolInterface::class, true)) {
-                if (($configClass = $driverClass::getConfigClass()) !== $config::class) {
-                    $config = new $configClass($config->toArray());
-                }
-                self::$instances[$instanceId] = new $driverClass(
-                    $config,
-                    $instanceId,
-                    EventManager::getInstance()
-                );
-            } else {
-                try {
-                    self::$driverExtensions[$driver] = ExtensionManager::getExtension($driver);
-                    return CacheManager::getInstance($driver, $config, $instanceId);
-                } catch (PhpfastcacheExtensionNotFoundException) {
-                    if (in_array($driver, ExtensionManager::KNOWN_EXTENSION_NAMES, true)) {
-                        throw new PhpfastcacheExtensionNotInstalledException(sprintf(
-                            'You requested a driver which is now an extension. Run the following command to solve this issue: %s',
-                            sprintf('composer install phpfastcache/%s-extension', strtolower($driver))
-                        ));
-                    }
-                    throw new PhpfastcacheDriverNotFoundException(sprintf(
-                        'The driver "%s" does not exist or does not implement %s.',
-                        $driver,
-                        ExtendedCacheItemPoolInterface::class,
-                    ));
-                }
-            }
-        }
-
-        return self::$instances[$instanceId];
-    }
-
-    /**
-     * @param string $driverClass
-     * @param ConfigurationOptionInterface $config
-     * @return string
-     */
-    protected static function getInstanceHash(string $driverClass, ConfigurationOptionInterface $config): string
-    {
-        return \md5($driverClass . \serialize(
-            \array_filter(
-                $config->toArray(),
-                static fn ($val) => $config->isValueSerializable($val)
-            )
-        ));
-    }
-
-    /**
-     * @param ConfigurationOptionInterface|null $config
-     * @return ConfigurationOptionInterface
-     * @throws PhpfastcacheLogicException
-     */
-    protected static function validateConfig(?ConfigurationOptionInterface $config): ConfigurationOptionInterface
-    {
-        if ($config instanceof ConfigurationOptionInterface && $config->isLocked()) {
-            throw new PhpfastcacheLogicException('You provided an already locked configuration, cannot continue.');
-        }
-        return $config ?? self::getDefaultConfig();
-    }
-
-    /**
-     * @return ConfigurationOptionInterface
-     */
-    public static function getDefaultConfig(): ConfigurationOptionInterface
-    {
-        return self::$config ?? self::$config = new ConfigurationOption();
-    }
-
-    /**
-     * @param string $driverName
-     * @return string
-     */
-    public static function normalizeDriverName(string $driverName): string
-    {
-        return \ucfirst(\strtolower(\trim($driverName)));
-    }
-
-    /**
-     * @param string $driverName
-     * @return string
-     */
-    public static function getDriverClass(string $driverName): string
-    {
-        if (!empty(self::$driverExtensions[$driverName])) {
-            $driverClass = self::$driverExtensions[$driverName];
-        } elseif (!empty(self::$driverCustoms[$driverName])) {
-            $driverClass = self::$driverCustoms[$driverName];
-        } elseif (!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 true;
-    }
-
-    /**
-     * @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 ConfigurationOptionInterface $config
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    public static function setDefaultConfig(ConfigurationOptionInterface $config): void
-    {
-        if (\is_subclass_of($config, ConfigurationOption::class)) {
-            throw new PhpfastcacheInvalidArgumentException('Default configuration cannot be a child class of ConfigurationOption::class');
-        }
-        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::normalizeDriverName($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 exist", $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;
-    }
-
-    /**
-     * @param string $driverName
-     * @return bool
-     */
-    public static function customDriverExists(string $driverName): bool
-    {
-        return isset(self::$driverCustoms[$driverName]);
-    }
-
-    /**
-     * 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 (\array_keys($classMap) as $class) {
-                    $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::normalizeDriverName($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 exist", $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::normalizeDriverName($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 exist", $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::normalizeDriverName($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]);
-    }
+	use ClassNamespaceResolverTrait;
+	use UninstanciableObjectTrait;
+
+	public const CORE_DRIVER_NAMESPACE = 'Phpfastcache\Drivers\\';
+
+	protected static ConfigurationOptionInterface $config;
+
+	protected static string $namespacePath;
+
+	/**
+	 * @var ExtendedCacheItemPoolInterface[]
+	 */
+	protected static array $instances = [];
+
+	/**
+	 * @var string[]
+	 */
+	protected static array $driverOverrides = [];
+
+	/**
+	 * @var string[]
+	 */
+	protected static array $driverCustoms = [];
+
+	/**
+	 * @var string[]
+	 */
+	protected static array $driverExtensions = [];
+
+	/**
+	 * @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;
+	}
+
+	/**
+	 * @param string $driver
+	 * @param ConfigurationOptionInterface|null $config
+	 * @param string|null $instanceId
+	 * @return ExtendedCacheItemPoolInterface
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheDriverNotFoundException
+	 * @throws PhpfastcacheExtensionNotInstalledException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public static function getInstance(string $driver, ?ConfigurationOptionInterface $config = null, ?string $instanceId = null): ExtendedCacheItemPoolInterface
+	{
+		if (\class_exists($driver) && \str_starts_with($driver, 'Phpfastcache')) {
+			$driverClass = $driver;
+		} else {
+			$driver = self::normalizeDriverName($driver);
+			$driverClass = self::getDriverClass($driver);
+		}
+		$config = self::validateConfig($config);
+		$instanceId = $instanceId ?: self::getInstanceHash($driverClass, $config);
+
+		if (!isset(self::$instances[$instanceId])) {
+			if (\is_a($driverClass, ExtendedCacheItemPoolInterface::class, true)) {
+				if (($configClass = $driverClass::getConfigClass()) !== $config::class) {
+					$config = new $configClass($config->toArray());
+				}
+				self::$instances[$instanceId] = new $driverClass(
+					$config,
+					$instanceId,
+					EventManager::getInstance()
+				);
+			} else {
+				try {
+					self::$driverExtensions[$driver] = ExtensionManager::getExtension($driver);
+					return CacheManager::getInstance($driver, $config, $instanceId);
+				} catch (PhpfastcacheExtensionNotFoundException) {
+					if (in_array($driver, ExtensionManager::KNOWN_EXTENSION_NAMES, true)) {
+						throw new PhpfastcacheExtensionNotInstalledException(sprintf(
+							'You requested a driver which is now an extension. Run the following command to solve this issue: %s',
+							sprintf('composer install phpfastcache/%s-extension', strtolower($driver))
+						));
+					}
+					throw new PhpfastcacheDriverNotFoundException(sprintf(
+						'The driver "%s" does not exist or does not implement %s.',
+						$driver,
+						ExtendedCacheItemPoolInterface::class,
+					));
+				}
+			}
+		}
+
+		return self::$instances[$instanceId];
+	}
+
+	/**
+	 * @param string $driverClass
+	 * @param ConfigurationOptionInterface $config
+	 * @return string
+	 */
+	protected static function getInstanceHash(string $driverClass, ConfigurationOptionInterface $config): string
+	{
+		return \md5($driverClass . \serialize(
+			\array_filter(
+				$config->toArray(),
+				static fn ($val) => $config->isValueSerializable($val)
+			)
+		));
+	}
+
+	/**
+	 * @param ConfigurationOptionInterface|null $config
+	 * @return ConfigurationOptionInterface
+	 * @throws PhpfastcacheLogicException
+	 */
+	protected static function validateConfig(?ConfigurationOptionInterface $config): ConfigurationOptionInterface
+	{
+		if ($config instanceof ConfigurationOptionInterface && $config->isLocked()) {
+			throw new PhpfastcacheLogicException('You provided an already locked configuration, cannot continue.');
+		}
+		return $config ?? self::getDefaultConfig();
+	}
+
+	/**
+	 * @return ConfigurationOptionInterface
+	 */
+	public static function getDefaultConfig(): ConfigurationOptionInterface
+	{
+		return self::$config ?? self::$config = new ConfigurationOption();
+	}
+
+	/**
+	 * @param string $driverName
+	 * @return string
+	 */
+	public static function normalizeDriverName(string $driverName): string
+	{
+		return \ucfirst(\strtolower(\trim($driverName)));
+	}
+
+	/**
+	 * @param string $driverName
+	 * @return string
+	 */
+	public static function getDriverClass(string $driverName): string
+	{
+		if (!empty(self::$driverExtensions[$driverName])) {
+			$driverClass = self::$driverExtensions[$driverName];
+		} elseif (!empty(self::$driverCustoms[$driverName])) {
+			$driverClass = self::$driverCustoms[$driverName];
+		} elseif (!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 true;
+	}
+
+	/**
+	 * @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 ConfigurationOptionInterface $config
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	public static function setDefaultConfig(ConfigurationOptionInterface $config): void
+	{
+		if (\is_subclass_of($config, ConfigurationOption::class)) {
+			throw new PhpfastcacheInvalidArgumentException('Default configuration cannot be a child class of ConfigurationOption::class');
+		}
+		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::normalizeDriverName($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 exist", $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;
+	}
+
+	/**
+	 * @param string $driverName
+	 * @return bool
+	 */
+	public static function customDriverExists(string $driverName): bool
+	{
+		return isset(self::$driverCustoms[$driverName]);
+	}
+
+	/**
+	 * 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 (\array_keys($classMap) as $class) {
+					$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::normalizeDriverName($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 exist", $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::normalizeDriverName($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 exist", $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::normalizeDriverName($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]);
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/CacheContract.php

Indentation +34 added lines, -34 removed lines

@@ -22,40 +22,40 @@
 
 class CacheContract
 {
-    protected CacheItemPoolInterface $cacheInstance;
-
-    public function __construct(CacheItemPoolInterface $cacheInstance)
-    {
-        $this->cacheInstance = $cacheInstance;
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     */
-    public function get(string|\Stringable $cacheKey, callable $callback, DateInterval|int $expiresAfter = null): mixed
-    {
-        $cacheItem = $this->cacheInstance->getItem((string) $cacheKey);
-
-        if (!$cacheItem->isHit()) {
-            /*
+	protected CacheItemPoolInterface $cacheInstance;
+
+	public function __construct(CacheItemPoolInterface $cacheInstance)
+	{
+		$this->cacheInstance = $cacheInstance;
+	}
+
+	/**
+	 * @throws InvalidArgumentException
+	 */
+	public function get(string|\Stringable $cacheKey, callable $callback, DateInterval|int $expiresAfter = null): mixed
+	{
+		$cacheItem = $this->cacheInstance->getItem((string) $cacheKey);
+
+		if (!$cacheItem->isHit()) {
+			/*
             * Parameter $cacheItem will be available as of 8.0.6
             */
-            $cacheItem->set($callback($cacheItem));
-            if ($expiresAfter) {
-                $cacheItem->expiresAfter($expiresAfter);
-            }
-
-            $this->cacheInstance->save($cacheItem);
-        }
-
-        return $cacheItem->get();
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     */
-    public function __invoke(string $cacheKey, callable $callback, DateInterval|int $expiresAfter = null): mixed
-    {
-        return $this->get($cacheKey, $callback, $expiresAfter);
-    }
+			$cacheItem->set($callback($cacheItem));
+			if ($expiresAfter) {
+				$cacheItem->expiresAfter($expiresAfter);
+			}
+
+			$this->cacheInstance->save($cacheItem);
+		}
+
+		return $cacheItem->get();
+	}
+
+	/**
+	 * @throws InvalidArgumentException
+	 */
+	public function __invoke(string $cacheKey, callable $callback, DateInterval|int $expiresAfter = null): mixed
+	{
+		return $this->get($cacheKey, $callback, $expiresAfter);
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Config/ConfigurationOptionInterface.php

Indentation +109 added lines, -109 removed lines

@@ -22,113 +22,113 @@
 
 interface ConfigurationOptionInterface extends LockableConfigurationInterface
 {
-    /**
-     * @param array<string, mixed> $parameters
-     * ConfigurationOptionInterface constructor.
-     */
-    public function __construct(array $parameters = []);
-
-    /**
-     * @return array<string, mixed>
-     */
-    public function toArray(): array;
-
-    /**
-     * @param mixed $val
-     * @return bool
-     */
-    public function isValueSerializable(mixed $val): bool;
-
-    /**
-     * @param string $optionName
-     * @return bool
-     */
-    public function isValidOption(string $optionName): bool;
-
-    /**
-     * @return bool
-     */
-    public function isItemDetailedDate(): bool;
-
-    /**
-     * @param bool $itemDetailedDate
-     * @return ConfigurationOption
-     */
-    public function setItemDetailedDate(bool $itemDetailedDate): static;
-
-    /**
-     * @return bool
-     */
-    public function isAutoTmpFallback(): bool;
-    /**
-     * @param bool $autoTmpFallback
-     * @return ConfigurationOption
-     */
-    public function setAutoTmpFallback(bool $autoTmpFallback): static;
-    /**
-     * @return int
-     */
-    public function getDefaultTtl(): int;
-    /**
-     * @param int $defaultTtl
-     * @return ConfigurationOption
-     */
-    public function setDefaultTtl(int $defaultTtl): static;
-    /**
-     * @return callable|string
-     */
-    public function getDefaultKeyHashFunction(): callable|string;
-    /**
-     * @param callable|string $defaultKeyHashFunction
-     * @return ConfigurationOption
-     * @throws  PhpfastcacheInvalidConfigurationException
-     */
-    public function setDefaultKeyHashFunction(callable|string $defaultKeyHashFunction): static;
-    /**
-     * @return callable|string
-     */
-    public function getDefaultFileNameHashFunction(): callable|string;
-    /**
-     * @param callable|string $defaultFileNameHashFunction
-     * @return ConfigurationOption
-     * @throws  PhpfastcacheInvalidConfigurationException
-     */
-    public function setDefaultFileNameHashFunction(callable|string $defaultFileNameHashFunction): static;
-
-    /**
-     * @return string
-     */
-    public function getPath(): string;
-
-    /**
-     * @param string $path
-     * @return ConfigurationOption
-     */
-    public function setPath(string $path): static;
-
-    /**
-     * @return bool
-     */
-    public function isUseStaticItemCaching(): bool;
-
-    /**
-     * @param bool $useStaticItemCaching
-     * @return ConfigurationOption
-     */
-    public function setUseStaticItemCaching(bool $useStaticItemCaching): static;
-
-    /**
-     * @return object
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function getSuperGlobalAccessor(): object;
-
-    /**
-     * @param ?object $superGlobalAccessor
-     * @return static
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function setSuperGlobalAccessor(?object $superGlobalAccessor): static;
+	/**
+	 * @param array<string, mixed> $parameters
+	 * ConfigurationOptionInterface constructor.
+	 */
+	public function __construct(array $parameters = []);
+
+	/**
+	 * @return array<string, mixed>
+	 */
+	public function toArray(): array;
+
+	/**
+	 * @param mixed $val
+	 * @return bool
+	 */
+	public function isValueSerializable(mixed $val): bool;
+
+	/**
+	 * @param string $optionName
+	 * @return bool
+	 */
+	public function isValidOption(string $optionName): bool;
+
+	/**
+	 * @return bool
+	 */
+	public function isItemDetailedDate(): bool;
+
+	/**
+	 * @param bool $itemDetailedDate
+	 * @return ConfigurationOption
+	 */
+	public function setItemDetailedDate(bool $itemDetailedDate): static;
+
+	/**
+	 * @return bool
+	 */
+	public function isAutoTmpFallback(): bool;
+	/**
+	 * @param bool $autoTmpFallback
+	 * @return ConfigurationOption
+	 */
+	public function setAutoTmpFallback(bool $autoTmpFallback): static;
+	/**
+	 * @return int
+	 */
+	public function getDefaultTtl(): int;
+	/**
+	 * @param int $defaultTtl
+	 * @return ConfigurationOption
+	 */
+	public function setDefaultTtl(int $defaultTtl): static;
+	/**
+	 * @return callable|string
+	 */
+	public function getDefaultKeyHashFunction(): callable|string;
+	/**
+	 * @param callable|string $defaultKeyHashFunction
+	 * @return ConfigurationOption
+	 * @throws  PhpfastcacheInvalidConfigurationException
+	 */
+	public function setDefaultKeyHashFunction(callable|string $defaultKeyHashFunction): static;
+	/**
+	 * @return callable|string
+	 */
+	public function getDefaultFileNameHashFunction(): callable|string;
+	/**
+	 * @param callable|string $defaultFileNameHashFunction
+	 * @return ConfigurationOption
+	 * @throws  PhpfastcacheInvalidConfigurationException
+	 */
+	public function setDefaultFileNameHashFunction(callable|string $defaultFileNameHashFunction): static;
+
+	/**
+	 * @return string
+	 */
+	public function getPath(): string;
+
+	/**
+	 * @param string $path
+	 * @return ConfigurationOption
+	 */
+	public function setPath(string $path): static;
+
+	/**
+	 * @return bool
+	 */
+	public function isUseStaticItemCaching(): bool;
+
+	/**
+	 * @param bool $useStaticItemCaching
+	 * @return ConfigurationOption
+	 */
+	public function setUseStaticItemCaching(bool $useStaticItemCaching): static;
+
+	/**
+	 * @return object
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function getSuperGlobalAccessor(): object;
+
+	/**
+	 * @param ?object $superGlobalAccessor
+	 * @return static
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setSuperGlobalAccessor(?object $superGlobalAccessor): static;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Config/LockableConfigurationInterface.php

Indentation +6 added lines, -6 removed lines

@@ -20,12 +20,12 @@
 
 interface LockableConfigurationInterface
 {
-    /**
-     * @internal
-     */
-    public function lock(ExtendedCacheItemPoolInterface $poolInstance): static;
+	/**
+	 * @internal
+	 */
+	public function lock(ExtendedCacheItemPoolInterface $poolInstance): static;
 
-    public function lockedBy(): ExtendedCacheItemPoolInterface;
+	public function lockedBy(): ExtendedCacheItemPoolInterface;
 
-    public function isLocked(): bool;
+	public function isLocked(): bool;
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Config/ConfigurationOption.php

Indentation +343 added lines, -343 removed lines

@@ -23,347 +23,347 @@
 
 class ConfigurationOption extends AbstractConfigurationOption implements ConfigurationOptionInterface
 {
-    protected bool $itemDetailedDate = false;
-
-    protected bool $autoTmpFallback = false;
-
-    protected int $defaultTtl = 900;
-
-    /**
-     * @var string|callable
-     */
-    protected mixed $defaultKeyHashFunction = 'md5';
-
-    /**
-     * @var string|callable
-     */
-    protected mixed $defaultFileNameHashFunction = 'md5';
-
-    protected string $path = '';
-
-    protected bool $preventCacheSlams = false;
-
-    protected int $cacheSlamsTimeout = 15;
-
-    protected bool $useStaticItemCaching = true;
-
-    protected ?object $superGlobalAccessor = null;
-
-    /**
-     * @inheritDoc
-     * @throws PhpfastcacheInvalidConfigurationException
-     * @throws PhpfastcacheInvalidTypeException
-     */
-    public function __construct(array $parameters = [])
-    {
-        foreach ($parameters as $configKey => $configVal) {
-            try {
-                if (\property_exists($this, $configKey)) {
-                    $this->{'set' . \ucfirst($configKey)}($configVal);
-                } else {
-                    throw new PhpfastcacheInvalidConfigurationException(
-                        sprintf(
-                            'Unknown configuration option name "%s" for the config class "%s". Allowed configurations options are "%s"',
-                            $configKey,
-                            $this::class,
-                            \implode('", "', \array_keys($this->toArray())),
-                        )
-                    );
-                }
-            } catch (\TypeError $e) {
-                throw new PhpfastcacheInvalidTypeException(
-                    \sprintf(
-                        'TypeError exception thrown while trying to set your configuration: %s',
-                        $e->getMessage()
-                    )
-                );
-            }
-        }
-    }
-
-    public function toArray(): array
-    {
-        return \get_object_vars($this);
-    }
-
-    /**
-     * @throws \ReflectionException
-     */
-    public function isValueSerializable(mixed $val): bool
-    {
-        return !\is_callable($val) && !(is_object($val) && (new \ReflectionClass($val))->isAnonymous());
-    }
-
-    /**
-     * @param string $optionName
-     * @return bool
-     */
-    public function isValidOption(string $optionName): bool
-    {
-        return \property_exists($this, $optionName);
-    }
-
-    /**
-     * @return bool
-     */
-    public function isItemDetailedDate(): bool
-    {
-        return $this->itemDetailedDate;
-    }
-
-    /**
-     * @param bool $itemDetailedDate
-     * @return ConfigurationOption
-     * @throws PhpfastcacheLogicException
-     */
-    public function setItemDetailedDate(bool $itemDetailedDate): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        $this->itemDetailedDate = $itemDetailedDate;
-        return $this;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isAutoTmpFallback(): bool
-    {
-        return $this->autoTmpFallback;
-    }
-
-    /**
-     * @param bool $autoTmpFallback
-     * @return ConfigurationOption
-     * @throws PhpfastcacheLogicException
-     */
-    public function setAutoTmpFallback(bool $autoTmpFallback): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        $this->autoTmpFallback = $autoTmpFallback;
-        return $this;
-    }
-
-    /**
-     * @return int
-     */
-    public function getDefaultTtl(): int
-    {
-        return $this->defaultTtl;
-    }
-
-    /**
-     * @param int $defaultTtl
-     * @return ConfigurationOption
-     * @throws PhpfastcacheLogicException
-     */
-    public function setDefaultTtl(int $defaultTtl): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        $this->defaultTtl = $defaultTtl;
-        return $this;
-    }
-
-    /**
-     * @return callable|string
-     */
-    public function getDefaultKeyHashFunction(): callable|string
-    {
-        return $this->defaultKeyHashFunction;
-    }
-
-    /**
-     * @param callable|string $defaultKeyHashFunction
-     * @return ConfigurationOption
-     * @throws  PhpfastcacheInvalidConfigurationException
-     * @throws PhpfastcacheLogicException
-     */
-    public function setDefaultKeyHashFunction(callable|string $defaultKeyHashFunction): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        if ($defaultKeyHashFunction && !\is_callable($defaultKeyHashFunction) && (\is_string($defaultKeyHashFunction) && !\function_exists($defaultKeyHashFunction))) {
-            throw new PhpfastcacheInvalidConfigurationException('defaultKeyHashFunction must be a valid function name string');
-        }
-        $this->defaultKeyHashFunction = $defaultKeyHashFunction;
-        return $this;
-    }
-
-    /**
-     * @return callable|string
-     */
-    public function getDefaultFileNameHashFunction(): callable|string
-    {
-        return $this->defaultFileNameHashFunction;
-    }
-
-    /**
-     * @param callable|string $defaultFileNameHashFunction
-     * @return ConfigurationOption
-     * @throws  PhpfastcacheInvalidConfigurationException
-     * @throws PhpfastcacheLogicException
-     */
-    public function setDefaultFileNameHashFunction(callable|string $defaultFileNameHashFunction): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        if (!\is_callable($defaultFileNameHashFunction) && (\is_string($defaultFileNameHashFunction) && !\function_exists($defaultFileNameHashFunction))) {
-            throw new PhpfastcacheInvalidConfigurationException('defaultFileNameHashFunction must be a valid function name string');
-        }
-        $this->defaultFileNameHashFunction = $defaultFileNameHashFunction;
-        return $this;
-    }
-
-    /**
-     * @return string
-     */
-    public function getPath(): string
-    {
-        return $this->path;
-    }
-
-    /**
-     * @param string $path
-     * @return ConfigurationOption
-     * @throws PhpfastcacheLogicException
-     */
-    public function setPath(string $path): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        $this->path = $path;
-        return $this;
-    }
-
-    /**
-     * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
-     * @return bool
-     */
-    public function isPreventCacheSlams(): bool
-    {
-        return $this->preventCacheSlams;
-    }
-
-    /**
-     * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
-     * @param bool $preventCacheSlams
-     * @return ConfigurationOption
-     * @throws PhpfastcacheLogicException
-     */
-    public function setPreventCacheSlams(bool $preventCacheSlams): static
-    {
-        if ($preventCacheSlams !== $this->preventCacheSlams) {
-            trigger_error(
-                'This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.',
-                E_USER_DEPRECATED
-            );
-        }
-
-        $this->enforceLockedProperty(__FUNCTION__);
-        $this->preventCacheSlams = $preventCacheSlams;
-        return $this;
-    }
-
-    /**
-     * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
-     * @return int
-     */
-    public function getCacheSlamsTimeout(): int
-    {
-        return $this->cacheSlamsTimeout;
-    }
-
-    /**
-     * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
-     * @param int $cacheSlamsTimeout
-     * @return ConfigurationOption
-     * @throws PhpfastcacheLogicException
-     */
-    public function setCacheSlamsTimeout(int $cacheSlamsTimeout): static
-    {
-        if ($cacheSlamsTimeout !== $this->cacheSlamsTimeout) {
-            trigger_error(
-                'This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.',
-                E_USER_DEPRECATED
-            );
-        }
-        $this->enforceLockedProperty(__FUNCTION__);
-        $this->cacheSlamsTimeout = $cacheSlamsTimeout;
-        return $this;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isUseStaticItemCaching(): bool
-    {
-        return $this->useStaticItemCaching;
-    }
-
-    /**
-     * @param bool $useStaticItemCaching
-     * @return ConfigurationOption
-     * @throws PhpfastcacheLogicException
-     */
-    public function setUseStaticItemCaching(bool $useStaticItemCaching): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        $this->useStaticItemCaching = $useStaticItemCaching;
-        return $this;
-    }
-
-    /**
-     * @return object
-     */
-    public function getSuperGlobalAccessor(): object
-    {
-        if (!isset($this->superGlobalAccessor)) {
-            $this->superGlobalAccessor = $this->getDefaultSuperGlobalAccessor();
-        }
-
-        return $this->superGlobalAccessor;
-    }
-
-    /**
-     * @param ?object $superGlobalAccessor
-     * @return static
-     * @throws PhpfastcacheInvalidArgumentException
-     * @throws PhpfastcacheLogicException
-     */
-    public function setSuperGlobalAccessor(?object $superGlobalAccessor): static
-    {
-        $this->enforceLockedProperty(__FUNCTION__);
-        /**
-         *  Symfony's implementation for users that want a good control of their code:
-         *
-         *  $config['superGlobalAccessor'] = \Closure::fromCallable(static function(string $superGlobalName, string $keyName) use ($request) {
-         *      return match ($superGlobalName) {
-         *          'SERVER' => $request->server->get($keyName),
-         *          'REQUEST' => $request->request->get($keyName),
-         *      };
-         *  });
-         */
-
-        if ($superGlobalAccessor === null) {
-            $this->superGlobalAccessor = $this->getDefaultSuperGlobalAccessor();
-        } elseif (!\is_callable($superGlobalAccessor)) {
-            throw new PhpfastcacheInvalidArgumentException('The "superGlobalAccessor" callback must be callable using "__invoke" or \Closure implementation');
-        } else {
-            $this->superGlobalAccessor = $superGlobalAccessor;
-        }
-
-        return $this;
-    }
-
-    /**
-     * @return \Closure
-     * @SuppressWarnings(PHPMD.Superglobals)
-     */
-    protected function getDefaultSuperGlobalAccessor(): \Closure
-    {
-        return \Closure::fromCallable(static function (string $superGlobalName, ?string $keyName = null): string|int|float|array|bool|null {
-            return match ($superGlobalName) {
-                'SERVER' => $keyName !== null ? $_SERVER[$keyName] ?? null : $_SERVER,
-                'REQUEST' => $keyName !== null ? $_REQUEST[$keyName] ?? null : $_REQUEST,
-                'COOKIE' => $keyName !== null ? $_COOKIE[$keyName] ?? null : $_COOKIE,
-                default => null,
-            };
-        });
-    }
+	protected bool $itemDetailedDate = false;
+
+	protected bool $autoTmpFallback = false;
+
+	protected int $defaultTtl = 900;
+
+	/**
+	 * @var string|callable
+	 */
+	protected mixed $defaultKeyHashFunction = 'md5';
+
+	/**
+	 * @var string|callable
+	 */
+	protected mixed $defaultFileNameHashFunction = 'md5';
+
+	protected string $path = '';
+
+	protected bool $preventCacheSlams = false;
+
+	protected int $cacheSlamsTimeout = 15;
+
+	protected bool $useStaticItemCaching = true;
+
+	protected ?object $superGlobalAccessor = null;
+
+	/**
+	 * @inheritDoc
+	 * @throws PhpfastcacheInvalidConfigurationException
+	 * @throws PhpfastcacheInvalidTypeException
+	 */
+	public function __construct(array $parameters = [])
+	{
+		foreach ($parameters as $configKey => $configVal) {
+			try {
+				if (\property_exists($this, $configKey)) {
+					$this->{'set' . \ucfirst($configKey)}($configVal);
+				} else {
+					throw new PhpfastcacheInvalidConfigurationException(
+						sprintf(
+							'Unknown configuration option name "%s" for the config class "%s". Allowed configurations options are "%s"',
+							$configKey,
+							$this::class,
+							\implode('", "', \array_keys($this->toArray())),
+						)
+					);
+				}
+			} catch (\TypeError $e) {
+				throw new PhpfastcacheInvalidTypeException(
+					\sprintf(
+						'TypeError exception thrown while trying to set your configuration: %s',
+						$e->getMessage()
+					)
+				);
+			}
+		}
+	}
+
+	public function toArray(): array
+	{
+		return \get_object_vars($this);
+	}
+
+	/**
+	 * @throws \ReflectionException
+	 */
+	public function isValueSerializable(mixed $val): bool
+	{
+		return !\is_callable($val) && !(is_object($val) && (new \ReflectionClass($val))->isAnonymous());
+	}
+
+	/**
+	 * @param string $optionName
+	 * @return bool
+	 */
+	public function isValidOption(string $optionName): bool
+	{
+		return \property_exists($this, $optionName);
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isItemDetailedDate(): bool
+	{
+		return $this->itemDetailedDate;
+	}
+
+	/**
+	 * @param bool $itemDetailedDate
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setItemDetailedDate(bool $itemDetailedDate): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		$this->itemDetailedDate = $itemDetailedDate;
+		return $this;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isAutoTmpFallback(): bool
+	{
+		return $this->autoTmpFallback;
+	}
+
+	/**
+	 * @param bool $autoTmpFallback
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setAutoTmpFallback(bool $autoTmpFallback): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		$this->autoTmpFallback = $autoTmpFallback;
+		return $this;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getDefaultTtl(): int
+	{
+		return $this->defaultTtl;
+	}
+
+	/**
+	 * @param int $defaultTtl
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setDefaultTtl(int $defaultTtl): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		$this->defaultTtl = $defaultTtl;
+		return $this;
+	}
+
+	/**
+	 * @return callable|string
+	 */
+	public function getDefaultKeyHashFunction(): callable|string
+	{
+		return $this->defaultKeyHashFunction;
+	}
+
+	/**
+	 * @param callable|string $defaultKeyHashFunction
+	 * @return ConfigurationOption
+	 * @throws  PhpfastcacheInvalidConfigurationException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setDefaultKeyHashFunction(callable|string $defaultKeyHashFunction): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		if ($defaultKeyHashFunction && !\is_callable($defaultKeyHashFunction) && (\is_string($defaultKeyHashFunction) && !\function_exists($defaultKeyHashFunction))) {
+			throw new PhpfastcacheInvalidConfigurationException('defaultKeyHashFunction must be a valid function name string');
+		}
+		$this->defaultKeyHashFunction = $defaultKeyHashFunction;
+		return $this;
+	}
+
+	/**
+	 * @return callable|string
+	 */
+	public function getDefaultFileNameHashFunction(): callable|string
+	{
+		return $this->defaultFileNameHashFunction;
+	}
+
+	/**
+	 * @param callable|string $defaultFileNameHashFunction
+	 * @return ConfigurationOption
+	 * @throws  PhpfastcacheInvalidConfigurationException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setDefaultFileNameHashFunction(callable|string $defaultFileNameHashFunction): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		if (!\is_callable($defaultFileNameHashFunction) && (\is_string($defaultFileNameHashFunction) && !\function_exists($defaultFileNameHashFunction))) {
+			throw new PhpfastcacheInvalidConfigurationException('defaultFileNameHashFunction must be a valid function name string');
+		}
+		$this->defaultFileNameHashFunction = $defaultFileNameHashFunction;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getPath(): string
+	{
+		return $this->path;
+	}
+
+	/**
+	 * @param string $path
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setPath(string $path): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		$this->path = $path;
+		return $this;
+	}
+
+	/**
+	 * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
+	 * @return bool
+	 */
+	public function isPreventCacheSlams(): bool
+	{
+		return $this->preventCacheSlams;
+	}
+
+	/**
+	 * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
+	 * @param bool $preventCacheSlams
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setPreventCacheSlams(bool $preventCacheSlams): static
+	{
+		if ($preventCacheSlams !== $this->preventCacheSlams) {
+			trigger_error(
+				'This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.',
+				E_USER_DEPRECATED
+			);
+		}
+
+		$this->enforceLockedProperty(__FUNCTION__);
+		$this->preventCacheSlams = $preventCacheSlams;
+		return $this;
+	}
+
+	/**
+	 * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
+	 * @return int
+	 */
+	public function getCacheSlamsTimeout(): int
+	{
+		return $this->cacheSlamsTimeout;
+	}
+
+	/**
+	 * @deprecated This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.
+	 * @param int $cacheSlamsTimeout
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setCacheSlamsTimeout(int $cacheSlamsTimeout): static
+	{
+		if ($cacheSlamsTimeout !== $this->cacheSlamsTimeout) {
+			trigger_error(
+				'This method is deprecated and will be soon moved to IOConfigurationOption class, which means they will only be available for `IO` drivers.',
+				E_USER_DEPRECATED
+			);
+		}
+		$this->enforceLockedProperty(__FUNCTION__);
+		$this->cacheSlamsTimeout = $cacheSlamsTimeout;
+		return $this;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isUseStaticItemCaching(): bool
+	{
+		return $this->useStaticItemCaching;
+	}
+
+	/**
+	 * @param bool $useStaticItemCaching
+	 * @return ConfigurationOption
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setUseStaticItemCaching(bool $useStaticItemCaching): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		$this->useStaticItemCaching = $useStaticItemCaching;
+		return $this;
+	}
+
+	/**
+	 * @return object
+	 */
+	public function getSuperGlobalAccessor(): object
+	{
+		if (!isset($this->superGlobalAccessor)) {
+			$this->superGlobalAccessor = $this->getDefaultSuperGlobalAccessor();
+		}
+
+		return $this->superGlobalAccessor;
+	}
+
+	/**
+	 * @param ?object $superGlobalAccessor
+	 * @return static
+	 * @throws PhpfastcacheInvalidArgumentException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setSuperGlobalAccessor(?object $superGlobalAccessor): static
+	{
+		$this->enforceLockedProperty(__FUNCTION__);
+		/**
+		 *  Symfony's implementation for users that want a good control of their code:
+		 *
+		 *  $config['superGlobalAccessor'] = \Closure::fromCallable(static function(string $superGlobalName, string $keyName) use ($request) {
+		 *      return match ($superGlobalName) {
+		 *          'SERVER' => $request->server->get($keyName),
+		 *          'REQUEST' => $request->request->get($keyName),
+		 *      };
+		 *  });
+		 */
+
+		if ($superGlobalAccessor === null) {
+			$this->superGlobalAccessor = $this->getDefaultSuperGlobalAccessor();
+		} elseif (!\is_callable($superGlobalAccessor)) {
+			throw new PhpfastcacheInvalidArgumentException('The "superGlobalAccessor" callback must be callable using "__invoke" or \Closure implementation');
+		} else {
+			$this->superGlobalAccessor = $superGlobalAccessor;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @return \Closure
+	 * @SuppressWarnings(PHPMD.Superglobals)
+	 */
+	protected function getDefaultSuperGlobalAccessor(): \Closure
+	{
+		return \Closure::fromCallable(static function (string $superGlobalName, ?string $keyName = null): string|int|float|array|bool|null {
+			return match ($superGlobalName) {
+				'SERVER' => $keyName !== null ? $_SERVER[$keyName] ?? null : $_SERVER,
+				'REQUEST' => $keyName !== null ? $_REQUEST[$keyName] ?? null : $_REQUEST,
+				'COOKIE' => $keyName !== null ? $_COOKIE[$keyName] ?? null : $_COOKIE,
+				default => null,
+			};
+		});
+	}
 }

plugins/files/php/vendor/phpfastcache/phpfastcache/lib/Phpfastcache/Config/IOConfigurationOption.php

Indentation +129 added lines, -129 removed lines

@@ -24,133 +24,133 @@
  */
 class IOConfigurationOption extends ConfigurationOption
 {
-    protected bool $secureFileManipulation = false;
-
-    protected string $securityKey = '';
-
-    protected string $cacheFileExtension = 'txt';
-
-    protected int $defaultChmod = 0777;
-
-    /**
-     * @return string
-     */
-    public function getSecurityKey(): string
-    {
-        return $this->securityKey;
-    }
-
-    /**
-     * @param string $securityKey
-     * @return static
-     * @throws PhpfastcacheLogicException
-     */
-    public function setSecurityKey(string $securityKey): static
-    {
-        return $this->setProperty('securityKey', $securityKey);
-    }
-
-    /**
-     * @return bool
-     */
-    public function isSecureFileManipulation(): bool
-    {
-        return $this->secureFileManipulation;
-    }
-
-    /**
-     * @param bool $secureFileManipulation
-     * @return static
-     * @throws PhpfastcacheLogicException
-     */
-    public function setSecureFileManipulation(bool $secureFileManipulation): static
-    {
-        return $this->setProperty('secureFileManipulation', $secureFileManipulation);
-    }
-
-
-    /**
-     * @return string
-     */
-    public function getCacheFileExtension(): string
-    {
-        return $this->cacheFileExtension;
-    }
-
-    /**
-     * @param string $cacheFileExtension
-     * @return static
-     * @throws PhpfastcacheInvalidConfigurationException
-     * @throws PhpfastcacheLogicException
-     */
-    public function setCacheFileExtension(string $cacheFileExtension): static
-    {
-        $safeFileExtensions = \explode('|', IOConfigurationOptionInterface::SAFE_FILE_EXTENSIONS);
-
-        if (\str_contains($cacheFileExtension, '.')) {
-            throw new PhpfastcacheInvalidConfigurationException('cacheFileExtension cannot contain a dot "."');
-        }
-        if (!\in_array($cacheFileExtension, $safeFileExtensions, true)) {
-            throw new PhpfastcacheInvalidConfigurationException(
-                "Extension \"$cacheFileExtension\" is unsafe, currently allowed extension names: " . \implode(', ', $safeFileExtensions)
-            );
-        }
-
-        return $this->setProperty('cacheFileExtension', $cacheFileExtension);
-    }
-
-    /**
-     * @return int
-     */
-    public function getDefaultChmod(): int
-    {
-        return $this->defaultChmod;
-    }
-
-    /**
-     * @param int $defaultChmod
-     * @return static
-     * @throws PhpfastcacheLogicException
-     */
-    public function setDefaultChmod(int $defaultChmod): static
-    {
-        return $this->setProperty('defaultChmod', $defaultChmod);
-    }
-
-
-    /**
-     * @return bool
-     */
-    public function isPreventCacheSlams(): bool
-    {
-        return $this->preventCacheSlams;
-    }
-
-    /**
-     * @param bool $preventCacheSlams
-     * @return static
-     * @throws PhpfastcacheLogicException
-     */
-    public function setPreventCacheSlams(bool $preventCacheSlams): static
-    {
-        return $this->setProperty('preventCacheSlams', $preventCacheSlams);
-    }
-
-    /**
-     * @return int
-     */
-    public function getCacheSlamsTimeout(): int
-    {
-        return $this->cacheSlamsTimeout;
-    }
-
-    /**
-     * @param int $cacheSlamsTimeout
-     * @return static
-     * @throws PhpfastcacheLogicException
-     */
-    public function setCacheSlamsTimeout(int $cacheSlamsTimeout): static
-    {
-        return $this->setProperty('cacheSlamsTimeout', $cacheSlamsTimeout);
-    }
+	protected bool $secureFileManipulation = false;
+
+	protected string $securityKey = '';
+
+	protected string $cacheFileExtension = 'txt';
+
+	protected int $defaultChmod = 0777;
+
+	/**
+	 * @return string
+	 */
+	public function getSecurityKey(): string
+	{
+		return $this->securityKey;
+	}
+
+	/**
+	 * @param string $securityKey
+	 * @return static
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setSecurityKey(string $securityKey): static
+	{
+		return $this->setProperty('securityKey', $securityKey);
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isSecureFileManipulation(): bool
+	{
+		return $this->secureFileManipulation;
+	}
+
+	/**
+	 * @param bool $secureFileManipulation
+	 * @return static
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setSecureFileManipulation(bool $secureFileManipulation): static
+	{
+		return $this->setProperty('secureFileManipulation', $secureFileManipulation);
+	}
+
+
+	/**
+	 * @return string
+	 */
+	public function getCacheFileExtension(): string
+	{
+		return $this->cacheFileExtension;
+	}
+
+	/**
+	 * @param string $cacheFileExtension
+	 * @return static
+	 * @throws PhpfastcacheInvalidConfigurationException
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setCacheFileExtension(string $cacheFileExtension): static
+	{
+		$safeFileExtensions = \explode('|', IOConfigurationOptionInterface::SAFE_FILE_EXTENSIONS);
+
+		if (\str_contains($cacheFileExtension, '.')) {
+			throw new PhpfastcacheInvalidConfigurationException('cacheFileExtension cannot contain a dot "."');
+		}
+		if (!\in_array($cacheFileExtension, $safeFileExtensions, true)) {
+			throw new PhpfastcacheInvalidConfigurationException(
+				"Extension \"$cacheFileExtension\" is unsafe, currently allowed extension names: " . \implode(', ', $safeFileExtensions)
+			);
+		}
+
+		return $this->setProperty('cacheFileExtension', $cacheFileExtension);
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getDefaultChmod(): int
+	{
+		return $this->defaultChmod;
+	}
+
+	/**
+	 * @param int $defaultChmod
+	 * @return static
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setDefaultChmod(int $defaultChmod): static
+	{
+		return $this->setProperty('defaultChmod', $defaultChmod);
+	}
+
+
+	/**
+	 * @return bool
+	 */
+	public function isPreventCacheSlams(): bool
+	{
+		return $this->preventCacheSlams;
+	}
+
+	/**
+	 * @param bool $preventCacheSlams
+	 * @return static
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setPreventCacheSlams(bool $preventCacheSlams): static
+	{
+		return $this->setProperty('preventCacheSlams', $preventCacheSlams);
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getCacheSlamsTimeout(): int
+	{
+		return $this->cacheSlamsTimeout;
+	}
+
+	/**
+	 * @param int $cacheSlamsTimeout
+	 * @return static
+	 * @throws PhpfastcacheLogicException
+	 */
+	public function setCacheSlamsTimeout(int $cacheSlamsTimeout): static
+	{
+		return $this->setProperty('cacheSlamsTimeout', $cacheSlamsTimeout);
+	}
 }