grommunio / grommunio-web

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

Spacing +2 added lines, -2 removed lines

@@ -32,7 +32,7 @@ 
     /**
      * @throws InvalidArgumentException
      */
-    public function get(string|\Stringable $cacheKey, callable $callback, DateInterval|int $expiresAfter = null): mixed
+    public function get(string | \Stringable $cacheKey, callable $callback, DateInterval | int $expiresAfter = null): mixed
     {
         $cacheItem = $this->cacheInstance->getItem((string) $cacheKey);
 
@@ -54,7 +54,7 @@ 
     /**
      * @throws InvalidArgumentException
      */
-    public function __invoke(string $cacheKey, callable $callback, DateInterval|int $expiresAfter = null): mixed
+    public function __invoke(string $cacheKey, callable $callback, DateInterval | int $expiresAfter = null): mixed
     {
         return $this->get($cacheKey, $callback, $expiresAfter);
     }

Braces +1 added lines, -2 removed lines

@@ -24,8 +24,7 @@
 {
     protected CacheItemPoolInterface $cacheInstance;
 
-    public function __construct(CacheItemPoolInterface $cacheInstance)
-    {
+    public function __construct(CacheItemPoolInterface $cacheInstance) {
         $this->cacheInstance = $cacheInstance;
     }
 

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;
 }

Spacing +4 added lines, -4 removed lines

@@ -77,23 +77,23 @@
     /**
      * @return callable|string
      */
-    public function getDefaultKeyHashFunction(): callable|string;
+    public function getDefaultKeyHashFunction(): callable | string;
     /**
      * @param callable|string $defaultKeyHashFunction
      * @return ConfigurationOption
      * @throws  PhpfastcacheInvalidConfigurationException
      */
-    public function setDefaultKeyHashFunction(callable|string $defaultKeyHashFunction): static;
+    public function setDefaultKeyHashFunction(callable | string $defaultKeyHashFunction): static;
     /**
      * @return callable|string
      */
-    public function getDefaultFileNameHashFunction(): callable|string;
+    public function getDefaultFileNameHashFunction(): callable | string;
     /**
      * @param callable|string $defaultFileNameHashFunction
      * @return ConfigurationOption
      * @throws  PhpfastcacheInvalidConfigurationException
      */
-    public function setDefaultFileNameHashFunction(callable|string $defaultFileNameHashFunction): static;
+    public function setDefaultFileNameHashFunction(callable | string $defaultFileNameHashFunction): static;
 
     /**
      * @return string

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

Spacing +5 added lines, -5 removed lines

@@ -166,7 +166,7 @@ 
     /**
      * @return callable|string
      */
-    public function getDefaultKeyHashFunction(): callable|string
+    public function getDefaultKeyHashFunction(): callable | string
     {
         return $this->defaultKeyHashFunction;
     }
@@ -177,7 +177,7 @@ 
      * @throws  PhpfastcacheInvalidConfigurationException
      * @throws PhpfastcacheLogicException
      */
-    public function setDefaultKeyHashFunction(callable|string $defaultKeyHashFunction): static
+    public function setDefaultKeyHashFunction(callable | string $defaultKeyHashFunction): static
     {
         $this->enforceLockedProperty(__FUNCTION__);
         if ($defaultKeyHashFunction && !\is_callable($defaultKeyHashFunction) && (\is_string($defaultKeyHashFunction) && !\function_exists($defaultKeyHashFunction))) {
@@ -190,7 +190,7 @@ 
     /**
      * @return callable|string
      */
-    public function getDefaultFileNameHashFunction(): callable|string
+    public function getDefaultFileNameHashFunction(): callable | string
     {
         return $this->defaultFileNameHashFunction;
     }
@@ -201,7 +201,7 @@ 
      * @throws  PhpfastcacheInvalidConfigurationException
      * @throws PhpfastcacheLogicException
      */
-    public function setDefaultFileNameHashFunction(callable|string $defaultFileNameHashFunction): static
+    public function setDefaultFileNameHashFunction(callable | string $defaultFileNameHashFunction): static
     {
         $this->enforceLockedProperty(__FUNCTION__);
         if (!\is_callable($defaultFileNameHashFunction) && (\is_string($defaultFileNameHashFunction) && !\function_exists($defaultFileNameHashFunction))) {
@@ -357,7 +357,7 @@ 
      */
     protected function getDefaultSuperGlobalAccessor(): \Closure
     {
-        return \Closure::fromCallable(static function (string $superGlobalName, ?string $keyName = null): string|int|float|array|bool|null {
+        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,

Braces +9 added lines, -6 removed lines

@@ -54,13 +54,13 @@ 
      * @throws PhpfastcacheInvalidConfigurationException
      * @throws PhpfastcacheInvalidTypeException
      */
-    public function __construct(array $parameters = [])
-    {
+    public function __construct(array $parameters = []) {
         foreach ($parameters as $configKey => $configVal) {
             try {
                 if (\property_exists($this, $configKey)) {
                     $this->{'set' . \ucfirst($configKey)}($configVal);
-                } else {
+                }
+                else {
                     throw new PhpfastcacheInvalidConfigurationException(
                         sprintf(
                             'Unknown configuration option name "%s" for the config class "%s". Allowed configurations options are "%s"',
@@ -70,7 +70,8 @@ 
                         )
                     );
                 }
-            } catch (\TypeError $e) {
+            }
+            catch (\TypeError $e) {
                 throw new PhpfastcacheInvalidTypeException(
                     \sprintf(
                         'TypeError exception thrown while trying to set your configuration: %s',
@@ -342,9 +343,11 @@ 
 
         if ($superGlobalAccessor === null) {
             $this->superGlobalAccessor = $this->getDefaultSuperGlobalAccessor();
-        } elseif (!\is_callable($superGlobalAccessor)) {
+        }
+        elseif (!\is_callable($superGlobalAccessor)) {
             throw new PhpfastcacheInvalidArgumentException('The "superGlobalAccessor" callback must be callable using "__invoke" or \Closure implementation');
-        } else {
+        }
+        else {
             $this->superGlobalAccessor = $superGlobalAccessor;
         }
 

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

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

Indentation +12 added lines, -12 removed lines

@@ -21,16 +21,16 @@
  */
 class Config extends ConfigurationOption
 {
-    public function __construct(array $parameters = [])
-    {
-        \trigger_error(
-            \sprintf(
-                '%s class is deprecated and will be removed in v10, use %s instead.',
-                self::class,
-                ConfigurationOption::class
-            ),
-            \E_USER_DEPRECATED
-        );
-        parent::__construct($parameters);
-    }
+	public function __construct(array $parameters = [])
+	{
+		\trigger_error(
+			\sprintf(
+				'%s class is deprecated and will be removed in v10, use %s instead.',
+				self::class,
+				ConfigurationOption::class
+			),
+			\E_USER_DEPRECATED
+		);
+		parent::__construct($parameters);
+	}
 }

Braces +1 added lines, -2 removed lines

@@ -21,8 +21,7 @@
  */
 class Config extends ConfigurationOption
 {
-    public function __construct(array $parameters = [])
-    {
+    public function __construct(array $parameters = []) {
         \trigger_error(
             \sprintf(
                 '%s class is deprecated and will be removed in v10, use %s instead.',

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

Indentation +17 added lines, -17 removed lines

@@ -18,33 +18,33 @@
 
 interface IOConfigurationOptionInterface extends ConfigurationOptionInterface
 {
-    /**
-     * Feel free to propose your own one
-     * by opening a pull request :)
-     */
-    public const SAFE_FILE_EXTENSIONS = 'txt|cache|db|pfc';
+	/**
+	 * Feel free to propose your own one
+	 * by opening a pull request :)
+	 */
+	public const SAFE_FILE_EXTENSIONS = 'txt|cache|db|pfc';
 
-    public function getSecurityKey(): string;
+	public function getSecurityKey(): string;
 
-    public function setSecurityKey(string $securityKey): static;
+	public function setSecurityKey(string $securityKey): static;
 
-    public function isSecureFileManipulation(): bool;
+	public function isSecureFileManipulation(): bool;
 
-    public function setSecureFileManipulation(bool $secureFileManipulation): static;
+	public function setSecureFileManipulation(bool $secureFileManipulation): static;
 
-    public function getCacheFileExtension(): string;
+	public function getCacheFileExtension(): string;
 
-    public function setCacheFileExtension(string $cacheFileExtension): static;
+	public function setCacheFileExtension(string $cacheFileExtension): static;
 
-    public function getDefaultChmod(): int;
+	public function getDefaultChmod(): int;
 
-    public function setDefaultChmod(int $defaultChmod): static;
+	public function setDefaultChmod(int $defaultChmod): static;
 
-    public function isPreventCacheSlams(): bool;
+	public function isPreventCacheSlams(): bool;
 
-    public function setPreventCacheSlams(bool $preventCacheSlams): static;
+	public function setPreventCacheSlams(bool $preventCacheSlams): static;
 
-    public function getCacheSlamsTimeout(): int;
+	public function getCacheSlamsTimeout(): int;
 
-    public function setCacheSlamsTimeout(int $cacheSlamsTimeout): static;
+	public function setCacheSlamsTimeout(int $cacheSlamsTimeout): static;
 }

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

Indentation +51 added lines, -51 removed lines

@@ -22,62 +22,62 @@
 
 abstract class AbstractConfigurationOption implements LockableConfigurationInterface
 {
-    private bool $lockedObject = false;
-    private ExtendedCacheItemPoolInterface $locker;
+	private bool $lockedObject = false;
+	private ExtendedCacheItemPoolInterface $locker;
 
-    protected function getClassName(): string
-    {
-        return $this::class;
-    }
+	protected function getClassName(): string
+	{
+		return $this::class;
+	}
 
-    public function lock(ExtendedCacheItemPoolInterface $poolInstance): static
-    {
-        $this->lockedObject = true;
-        $this->locker = $poolInstance;
-        return $this;
-    }
+	public function lock(ExtendedCacheItemPoolInterface $poolInstance): static
+	{
+		$this->lockedObject = true;
+		$this->locker = $poolInstance;
+		return $this;
+	}
 
-    public function lockedBy(): ExtendedCacheItemPoolInterface
-    {
-        return $this->locker;
-    }
+	public function lockedBy(): ExtendedCacheItemPoolInterface
+	{
+		return $this->locker;
+	}
 
-    public function isLocked(): bool
-    {
-        return $this->lockedObject;
-    }
+	public function isLocked(): bool
+	{
+		return $this->lockedObject;
+	}
 
-    /**
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheInvalidArgumentException
-     */
-    protected function setProperty(string $propertyName, mixed $propertyValue): static
-    {
-        $this->enforceLockedProperty($propertyName);
-        if (property_exists($this, $propertyName)) {
-            $this->$propertyName = $propertyValue;
-            return $this;
-        }
-        throw new PhpfastcacheInvalidArgumentException("Unknown property $propertyName in {$this->getClassName()} context.");
-    }
+	/**
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheInvalidArgumentException
+	 */
+	protected function setProperty(string $propertyName, mixed $propertyValue): static
+	{
+		$this->enforceLockedProperty($propertyName);
+		if (property_exists($this, $propertyName)) {
+			$this->$propertyName = $propertyValue;
+			return $this;
+		}
+		throw new PhpfastcacheInvalidArgumentException("Unknown property $propertyName in {$this->getClassName()} context.");
+	}
 
-    /**
-     * @throws PhpfastcacheLogicException
-     */
-    protected function enforceLockedProperty(string $propertyName): void
-    {
-        if ($this->lockedObject === true) {
-            $dbt = \debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 3);
-            $cause = $dbt[\array_key_last($dbt)] ?? null;
-            if ($cause) {
-                $moreInfo = \sprintf('Caused line %d in %s', $cause['line'], $cause['file']);
-            }
+	/**
+	 * @throws PhpfastcacheLogicException
+	 */
+	protected function enforceLockedProperty(string $propertyName): void
+	{
+		if ($this->lockedObject === true) {
+			$dbt = \debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 3);
+			$cause = $dbt[\array_key_last($dbt)] ?? null;
+			if ($cause) {
+				$moreInfo = \sprintf('Caused line %d in %s', $cause['line'], $cause['file']);
+			}
 
-            throw new PhpfastcacheLogicException(\sprintf(
-                'You can no longer change the configuration "%s" as the cache pool instance is now running. %s',
-                $propertyName,
-                $moreInfo ?? ''
-            ));
-        }
-    }
+			throw new PhpfastcacheLogicException(\sprintf(
+				'You can no longer change the configuration "%s" as the cache pool instance is now running. %s',
+				$propertyName,
+				$moreInfo ?? ''
+			));
+		}
+	}
 }

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

Indentation +178 added lines, -178 removed lines

@@ -35,182 +35,182 @@
 
 class Psr16Adapter implements CacheInterface
 {
-    /**
-     * @var ExtendedCacheItemPoolInterface
-     */
-    protected ExtendedCacheItemPoolInterface $internalCacheInstance;
-
-    /**
-     * Psr16Adapter constructor.
-     * @param string|ExtendedCacheItemPoolInterface $driver
-     * @param null|ConfigurationOptionInterface $config
-     * @throws PhpfastcacheDriverCheckException
-     * @throws PhpfastcacheLogicException
-     * @throws PhpfastcacheDriverException
-     * @throws PhpfastcacheDriverNotFoundException
-     */
-    public function __construct(string|ExtendedCacheItemPoolInterface $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 $default
-     * @return mixed
-     * @throws PhpfastcacheSimpleCacheException
-     */
-    public function get(string $key, mixed $default = null): mixed
-    {
-        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
-     */
-    public function set(string $key, mixed $value, null|int|\DateInterval $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
-     * @throws InvalidArgumentException
-     */
-    public function delete(string $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<string> $keys
-     * @param null $default
-     * @return ExtendedCacheItemInterface[]
-     * @throws PhpfastcacheSimpleCacheException
-     */
-    public function getMultiple(iterable $keys, mixed $default = null): iterable
-    {
-        if ($keys instanceof Traversable) {
-            $keys = \iterator_to_array($keys);
-        }
-        try {
-            return \array_map(
-                static fn (ExtendedCacheItemInterface $item) => $item->isHit() ? $item->get() : $default,
-                $this->internalCacheInstance->getItems($keys)
-            );
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param iterable<string, mixed> $values
-     * @param null|int|DateInterval $ttl
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     */
-    public function setMultiple(iterable $values, null|int|\DateInterval $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<string> $keys
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     * @throws InvalidArgumentException
-     */
-    public function deleteMultiple(iterable $keys): bool
-    {
-        try {
-            if (\is_array($keys)) {
-                return $this->internalCacheInstance->deleteItems($keys);
-            }
-
-            return $this->internalCacheInstance->deleteItems(\iterator_to_array($keys));
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
-
-    /**
-     * @param string $key
-     * @return bool
-     * @throws PhpfastcacheSimpleCacheException
-     */
-    public function has(string $key): bool
-    {
-        try {
-            $cacheItem = $this->internalCacheInstance->getItem($key);
-            return $cacheItem->isHit() && !$cacheItem->isExpired();
-        } catch (PhpfastcacheInvalidArgumentException $e) {
-            throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
-        }
-    }
+	/**
+	 * @var ExtendedCacheItemPoolInterface
+	 */
+	protected ExtendedCacheItemPoolInterface $internalCacheInstance;
+
+	/**
+	 * Psr16Adapter constructor.
+	 * @param string|ExtendedCacheItemPoolInterface $driver
+	 * @param null|ConfigurationOptionInterface $config
+	 * @throws PhpfastcacheDriverCheckException
+	 * @throws PhpfastcacheLogicException
+	 * @throws PhpfastcacheDriverException
+	 * @throws PhpfastcacheDriverNotFoundException
+	 */
+	public function __construct(string|ExtendedCacheItemPoolInterface $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 $default
+	 * @return mixed
+	 * @throws PhpfastcacheSimpleCacheException
+	 */
+	public function get(string $key, mixed $default = null): mixed
+	{
+		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
+	 */
+	public function set(string $key, mixed $value, null|int|\DateInterval $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
+	 * @throws InvalidArgumentException
+	 */
+	public function delete(string $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<string> $keys
+	 * @param null $default
+	 * @return ExtendedCacheItemInterface[]
+	 * @throws PhpfastcacheSimpleCacheException
+	 */
+	public function getMultiple(iterable $keys, mixed $default = null): iterable
+	{
+		if ($keys instanceof Traversable) {
+			$keys = \iterator_to_array($keys);
+		}
+		try {
+			return \array_map(
+				static fn (ExtendedCacheItemInterface $item) => $item->isHit() ? $item->get() : $default,
+				$this->internalCacheInstance->getItems($keys)
+			);
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param iterable<string, mixed> $values
+	 * @param null|int|DateInterval $ttl
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 */
+	public function setMultiple(iterable $values, null|int|\DateInterval $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<string> $keys
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 * @throws InvalidArgumentException
+	 */
+	public function deleteMultiple(iterable $keys): bool
+	{
+		try {
+			if (\is_array($keys)) {
+				return $this->internalCacheInstance->deleteItems($keys);
+			}
+
+			return $this->internalCacheInstance->deleteItems(\iterator_to_array($keys));
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @return bool
+	 * @throws PhpfastcacheSimpleCacheException
+	 */
+	public function has(string $key): bool
+	{
+		try {
+			$cacheItem = $this->internalCacheInstance->getItem($key);
+			return $cacheItem->isHit() && !$cacheItem->isExpired();
+		} catch (PhpfastcacheInvalidArgumentException $e) {
+			throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
+		}
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -49,7 +49,7 @@ 
      * @throws PhpfastcacheDriverException
      * @throws PhpfastcacheDriverNotFoundException
      */
-    public function __construct(string|ExtendedCacheItemPoolInterface $driver, ConfigurationOptionInterface $config = null)
+    public function __construct(string | ExtendedCacheItemPoolInterface $driver, ConfigurationOptionInterface $config = null)
     {
         if ($driver instanceof ExtendedCacheItemPoolInterface) {
             if ($config !== null) {
@@ -88,7 +88,7 @@ 
      * @return bool
      * @throws PhpfastcacheSimpleCacheException
      */
-    public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+    public function set(string $key, mixed $value, null | int | \DateInterval $ttl = null): bool
     {
         try {
             $cacheItem = $this->internalCacheInstance
@@ -160,7 +160,7 @@ 
      * @return bool
      * @throws PhpfastcacheSimpleCacheException
      */
-    public function setMultiple(iterable $values, null|int|\DateInterval $ttl = null): bool
+    public function setMultiple(iterable $values, null | int | \DateInterval $ttl = null): bool
     {
         try {
             foreach ($values as $key => $value) {

Braces +23 added lines, -13 removed lines

@@ -49,14 +49,14 @@ 
      * @throws PhpfastcacheDriverException
      * @throws PhpfastcacheDriverNotFoundException
      */
-    public function __construct(string|ExtendedCacheItemPoolInterface $driver, ConfigurationOptionInterface $config = null)
-    {
+    public function __construct(string|ExtendedCacheItemPoolInterface $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);
         }
     }
@@ -76,7 +76,8 @@ 
             }
 
             return $default;
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -96,11 +97,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);
         }
     }
@@ -115,7 +118,8 @@ 
     {
         try {
             return $this->internalCacheInstance->deleteItem($key);
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -128,7 +132,8 @@ 
     {
         try {
             return $this->internalCacheInstance->clear();
-        } catch (PhpfastcacheRootException $e) {
+        }
+        catch (PhpfastcacheRootException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -149,7 +154,8 @@ 
                 static fn (ExtendedCacheItemInterface $item) => $item->isHit() ? $item->get() : $default,
                 $this->internalCacheInstance->getItems($keys)
             );
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -168,14 +174,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);
         }
     }
@@ -194,7 +202,8 @@ 
             }
 
             return $this->internalCacheInstance->deleteItems(\iterator_to_array($keys));
-        } catch (PhpfastcacheInvalidArgumentException $e) {
+        }
+        catch (PhpfastcacheInvalidArgumentException $e) {
             throw new PhpfastcacheSimpleCacheException($e->getMessage(), 0, $e);
         }
     }
@@ -209,7 +218,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);
         }
     }