XoopsCache::resolveEngineConfig() - Code Metrics - Inspection of "fix Using null as an array offset is deprecated, u..." - XOOPS/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#1596)

by Michael
created 2026-01-02 17:14 UTC
XoopsCache::resolveEngineConfig() A

↳ Parent: XoopsCache
Complexity

Conditions	5
Paths	2
Size

Total Lines	14
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	5
eloc	8
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	14
rs	9.6111
<?php
/**
 * Cache engine For XOOPS
 *
 * You may not change or alter any portion of this comment or credits
 * of supporting developers from this source code or any supporting source code
 * which is considered copyrighted (c) material of the original comment or credit authors.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * @copyright       (c) 2000-2025 XOOPS Project (https://xoops.org)
 * @license             GNU GPL 2 (https://www.gnu.org/licenses/gpl-2.0.html)
 * @package             class
 * @subpackage          cache
 * @since               2.3.0
 * @author              Taiwen Jiang <[email protected]>
 */

defined('XOOPS_ROOT_PATH') || exit('Restricted access');

/**
 * Caching for CakePHP.
 *
 * @package    cake
 * @subpackage cake.cake.libs
 */
class XoopsCache
{
    /**
     * Cache engine instances
     *
     * @var array<string, XoopsCacheEngine|null>
     * @access protected
     */
    protected $engine = [];


    /**
     * Cache configuration stack
     *
     * @var array
     * @access private
     */
    private $configs = [];

    /**
     * Holds name of the current configuration being used
     *
     * @var string|null
     * @access private
     */
    private $name;

    /**
     * XoopsCache::__construct()
     */
    public function __construct() {}

    /**
     * Returns a singleton instance
     *
     * @return object
     * @access public
     */
    public static function getInstance()
    {
        static $instance;
        if (!isset($instance)) {
            $class    = self::class;
            $instance = new $class();
        }

        return $instance;
    }

    /**
     * Resolves and validates engine configuration
     *
     * @param string|array|null $config Configuration name or array
     * @return array{engine: string, settings: array<string, mixed>}|false
     */
    private function resolveEngineConfig($config)
    {
        $config = $this->config($config);

        if (
            !is_array($config) ||
            !isset($config['engine'], $config['settings']) ||
            !is_string($config['engine']) ||
            !is_array($config['settings'])
        ) {
            return false;
        }

        return $config;
    }

    /**
     * Resolve engine name from parameter or current configuration
     *
     * @param string|null $engine Engine name or null to use current
     * @return string|null Engine name or null if cannot be resolved
     */
    private function resolveEngineName($engine)
    {
        if ($engine !== null && is_string($engine) && $engine !== '') {
            return $engine;
        }

        if (
            is_string($this->name) &&
            $this->name !== '' &&
            isset($this->configs[$this->name]['engine'])
        ) {
            return $this->configs[$this->name]['engine'];
        }

        return null;
    }

    /**
     * Tries to find and include a file for a cache engine
     *
     * @param  string $name Name of the engine
     * @return bool True if the engine was successfully loaded, false on failure
     * @access private
     */
    private function loadEngine($name)
    {
        if (!class_exists('XoopsCache' . ucfirst($name))) {
            if (file_exists($file = __DIR__ . '/' . strtolower($name) . '.php')) {
                include $file;
            } else {
                trigger_error('File :' . $file . ' not found in file : ' . __FILE__ . ' at line: ' . __LINE__, E_USER_WARNING);
                return false;
            }
        }

        return true;
    }

    /**
     * Set the cache configuration to use
     *
     * @param  string|array $name     Name of the configuration
     * @param  array  $settings Optional associative array of settings passed to the engine
     * @return array|false  (engine, settings) on success, false on failure
     * @access public
     */
    public function config($name = 'default', $settings = [])
    {
        $_this = XoopsCache::getInstance();

        if (!is_array($settings)) {

            $settings = [];
        }

        if (is_array($name)) {
            $config = $name;

            if (isset($config['name']) && is_string($config['name'])) {
                $name = $config['name'];
            } else {
                $name = 'default';
            }

            if (isset($config['settings']) && is_array($config['settings'])) {
                $settings = $config['settings'];
            }
        }

        if (!is_string($name) || $name === '') {

            $name = 'default';
        }

        if (isset($_this->configs[$name])) {
            $settings = array_merge($_this->configs[$name], $settings);
        } elseif (!empty($settings)) {
            $_this->configs[$name] = $settings;
        } elseif (
            $_this->configs !== null
            && is_string($_this->name)
            && $_this->name !== ''
            && isset($_this->configs[$_this->name])
        ) {
            $name     = $_this->name;
            $settings = $_this->configs[$_this->name];
        } else {
            $name = 'default';
            if (!empty($_this->configs['default'])) {
                $settings = $_this->configs['default'];
            } else {
                $settings = [
                    'engine' => 'file',
                ];
            }
        }

        $engine = !empty($settings['engine']) ? $settings['engine'] : 'file';

        if ($name !== $_this->name) {
            if ($_this->engine($engine, $settings) === false) {
                trigger_error("Cache Engine {$engine} is not set", E_USER_WARNING);

                return false;
            }
            $_this->name           = $name;
            $_this->configs[$name] = $_this->settings($engine);
        }

        $settings = $_this->configs[$name];

        return compact('engine', 'settings');
    }

    /**
     * Set the cache engine to use or modify settings for one instance
     *
     * @param  string $name     Name of the engine (without 'Engine')
     * @param  array  $settings Optional associative array of settings passed to the engine
     * @return bool True on success, false on failure
     * @access public
     */
    public function engine($name = 'file', $settings = []): bool
    {
        if (!is_string($name) || $name === '') {

            return false;
        }
        if (!is_array($settings)) {

            $settings = [];
        }

        $cacheClass = 'XoopsCache' . ucfirst($name);
        $_this      = XoopsCache::getInstance();

        if (!isset($_this->engine[$name])) {
            if ($_this->loadEngine($name) === false) {
                trigger_error("Cache Engine {$name} is not loaded", E_USER_WARNING);
                return false;
            }

            $_this->engine[$name] = new $cacheClass();

            // Validate that the engine implements the required interface
            if (!$_this->engine[$name] instanceof XoopsCacheEngineInterface) {
                $_this->engine[$name] = null;
                trigger_error(
                    "Cache engine {$name} must implement XoopsCacheEngineInterface",
                    E_USER_WARNING
                );
                return false;
            }
        }

        if ($_this->engine[$name]->init($settings)) {
            // Safely check probability before using it
            $probability = $_this->engine[$name]->settings['probability'] ?? 0;
            if ($probability > 0 && time() % $probability === 0) {
                $_this->engine[$name]->gc();
            }
            return true;
        }

        $_this->engine[$name] = null;
        trigger_error("Cache Engine {$name} is not initialized", E_USER_WARNING);

        return false;
    }

    /**
     * Garbage collection
     *
     * Permanently remove all expired and deleted data
     *
     * @return bool True on success, false on failure
     * @access public
     */
    public function gc(): bool
    {
        $_this  = XoopsCache::getInstance();
        $config = $_this->resolveEngineConfig(null);

        if ($config === false) {
            return false;
        }

        $engine = $config['engine'];

// Engine configuration is valid, but runtime initialization may have failed
        if (!$_this->isInitialized($engine)) {
            trigger_error("Cache engine {$engine} not initialized for garbage collection", E_USER_WARNING);
            return false;
        }

        $_this->engine[$engine]->gc();

        return true;
    }

    /**
     * Write data for key into cache
     *
     * @param  string $key       Identifier for the data
     * @param  mixed  $value     Data to be cached - anything except a resource
     * @param  mixed  $duration  Optional - string configuration name OR how long to cache the data, either in seconds or a
     *                           string that can be parsed by the strtotime() function OR array('config' => 'default', 'duration' => '3600')
     * @return bool True if the data was successfully cached, false on failure
     * @access public
     */
    public static function write($key, $value, $duration = null): bool
    {
        $key    = substr(md5(XOOPS_URL), 0, 8) . '_' . $key;
        $_this  = XoopsCache::getInstance();

        $config = null;

        if (is_array($duration)) {
            if (isset($duration['config']) && is_string($duration['config'])) {
                $config = $duration['config'];
            }
            if (isset($duration['duration'])) {
                $duration = $duration['duration'];
            } else {
                $duration = null;
            }
        } elseif (
            is_string($duration)
            && $duration !== ''
            && isset($_this->configs[$duration])
        ) {
            $config   = $duration;
            $duration = null;
        }

        $config = $_this->resolveEngineConfig($config);
        if ($config === false) {
            return false;
        }

        $engine   = $config['engine'];
        $settings = $config['settings'];

        if (!$_this->isInitialized($engine)) {
            trigger_error('Cache write not initialized: ' . $engine);

            return false;
        }

        if (!$key = $_this->key($key)) {
            return false;
        }

        if (is_resource($value)) {
            return false;
        }

        if (!$duration) {
            $duration = $settings['duration'];
        }
        $duration = is_numeric($duration) ? (int) $duration : strtotime($duration) - time();

        if ($duration < 1) {
            return false;
        }
        $_this->engine[$engine]->init($settings);
        $success = $_this->engine[$engine]->write($key, $value, $duration);

        return $success;
    }

    /**
     * Read a key from the cache
     *
     * @param  string $key    Identifier for the data
     * @param  string|array|null $config name of the configuration to use
     * @return mixed The cached data, or false if:
     *               - Configuration is invalid
     *               - Data doesn't exist
     *               - Data has expired
     *               - Error occurred during retrieval
     * @access public
     */
    public static function read($key, $config = null)
    {
        $key    = substr(md5(XOOPS_URL), 0, 8) . '_' . $key;
        $_this  = XoopsCache::getInstance();

        $config = $_this->resolveEngineConfig($config);
        if ($config === false) {
            return false;
        }

        $engine   = $config['engine'];
        $settings = $config['settings'];

        if (!$_this->isInitialized($engine)) {
            return false;
        }
        if (!$key = $_this->key($key)) {
            return false;
        }
        $_this->engine[$engine]->init($settings);
        $success = $_this->engine[$engine]->read($key);

        return $success;
    }

    /**
     * Delete a key from the cache
     *
     * @param  string $key    Identifier for the data
     * @param string|null $config name of the configuration to use
     * @return boolean True if the value was successfully deleted, false if it didn't exist or couldn't be removed
     * @access public
     */
    public static function delete($key, $config = null): bool
    {
        $key   = substr(md5(XOOPS_URL), 0, 8) . '_' . $key;
        $_this = XoopsCache::getInstance();

        $config = $_this->resolveEngineConfig($config);
        if ($config === false) {
            return false;
        }

        $engine   = $config['engine'];
        $settings = $config['settings'];

        if (!$_this->isInitialized($engine)) {
            return false;
        }

        if (!$key = $_this->key($key)) {
            return false;
        }

        $_this->engine[$engine]->init($settings);
        $success = $_this->engine[$engine]->delete($key);

        return $success;
    }

    /**
     * Delete all keys from the cache
     *
     * @param  boolean $check  if true will check expiration, otherwise delete all
     * @param string|null $config name of the configuration to use
     * @return boolean True if the cache was successfully cleared, false otherwise
     * @access public
     */
    public function clear($check = false, $config = null): bool
    {
        $_this = XoopsCache::getInstance();

        $config = $_this->resolveEngineConfig($config);
        if ($config === false) {
            return false;
        }

        $engine   = $config['engine'];
        $settings = $config['settings'];

        if (!$_this->isInitialized($engine)) {
            return false;
        }

        $success = $_this->engine[$engine]->clear($check);
        $_this->engine[$engine]->init($settings);

        return $success;
    }


    /**
     * Check if Cache has initialized a working storage engine
     *
     * @param  string|null $engine Name of the engine
     * @return bool
     * @access public
     */
    public function isInitialized($engine = null)
    {
        $_this = XoopsCache::getInstance();
        $engine = $_this->resolveEngineName($engine);

        return is_string($engine)
            && isset($_this->engine[$engine])
            && $_this->engine[$engine] instanceof XoopsCacheEngineInterface;
    }

    /**
     * Return the settings for current cache engine
     *
     * @param  string|null $engine Name of the engine
     * @return array<string, mixed> list of settings for this engine
     * @access public
     */
    public function settings($engine = null): array
    {
        $_this = XoopsCache::getInstance();
        $engine = $_this->resolveEngineName($engine);

        if (
            is_string($engine) &&
            isset($_this->engine[$engine]) &&
            $_this->engine[$engine] instanceof XoopsCacheEngineInterface
        ) {
            return $_this->engine[$engine]->settings();
        }

        return [];
    }

    /**
     * generates a safe key
     *
     * @param  string $key the key passed over
     * @return mixed  string $key or false
     * @access private
     */
    public function key($key)
    {
        if (empty($key)) {
            return false;
        }
        $key = str_replace(['/', '.'], '_', (string) $key);

        return $key;
    }
}

/**
 * Interface for XOOPS cache engine implementations
 *
 * Defines the contract that all cache engines must implement.
 * Third-party cache engines should implement this interface.
 *
 * @package    core
 * @subpackage cache
 * @since      2.5.12
 * @deprecated 4.0.0 Use Xoops\Core\Cache\EngineInterface instead
 */
interface XoopsCacheEngineInterface
{
    public function init($settings = []);
    public function gc();
    public function write($key, $value, $duration = null);
    public function read($key);
    public function delete($key);
    public function clear($check);
    public function settings();
}

/**
 * Abstract class for storage engine for caching
 *
 * @package    core
 * @subpackage cache
 */
abstract class XoopsCacheEngine implements XoopsCacheEngineInterface
abstract class XoopsCacheEngine implements /** @scrutinizer ignore-deprecated */ XoopsCacheEngineInterface
{
    /**
     * settings of current engine instance
     *
     * @var array
     * @access public
     */
    public $settings;

    /**
     * Initialize the cache engine
     *
     * Called automatically by the cache frontend. This method may be called
     * multiple times to reconfigure the engine with different settings.
     * Implementations should handle repeated initialization gracefully.
     *
     * @param  array $settings Associative array of parameters for the engine
     * @return boolean True if the engine has been successfully initialized, false if not
     * @access   public
     */
    public function init($settings = [])
    {
        $this->settings = array_merge(
            [
                'duration'    => 31556926,
                'probability' => 100,
            ],
            $settings,
        );

        return true;
    }

    /**
     * Garbage collection
     *
     * Permanently remove all expired and deleted data
     *
     * @access public
     */
    public function gc() {}

    /**
     * Write value for a key into cache
     *
     * @param  string $key      Identifier for the data
     * @param  mixed  $value    Data to be cached
     * @param  mixed  $duration How long to cache the data, in seconds
     * @return boolean True if the data was successfully cached, false on failure
     * @access public
     */
    public function write($key, $value, $duration = null)
    {
        trigger_error(sprintf(__('Method write() not implemented in %s', true), get_class($this)), E_USER_ERROR);
        trigger_error(sprintf(/** @scrutinizer ignore-call */ __('Method write() not implemented in %s', true), get_class($this)), E_USER_ERROR);
    }

    /**
     * Read a key from the cache
     *
     * @param  string $key Identifier for the data
     * @return mixed  The cached data, or false if the data doesn't exist, has expired, or if there was an error fetching it
     * @access public
     */
    public function read($key)
    {
        trigger_error(sprintf(__('Method read() not implemented in %s', true), get_class($this)), E_USER_ERROR);
        trigger_error(sprintf(/** @scrutinizer ignore-call */ __('Method read() not implemented in %s', true), get_class($this)), E_USER_ERROR);
    }

    /**
     * Delete a key from the cache
     *
     * @param  string $key Identifier for the data
     * @return boolean True if the value was successfully deleted, false if it didn't exist or couldn't be removed
     * @access public
     */
    public function delete($key) {}

    /**
     * Delete all keys from the cache
     *
     * @param  boolean $check if true will check expiration, otherwise delete all
     * @return boolean True if the cache was successfully cleared, false otherwise
     * @access public
     */
    public function clear($check) {}

    /**
     * Cache Engine settings
     *
     * @return array settings
     * @access public
     */
    public function settings()
    {
        return $this->settings;
    }
}

XOOPS / XoopsCore25

Pull Request — master (#1596)

XoopsCache::resolveEngineConfig() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
