Silviooosilva\CacheerPhp\CacheStore\ArrayCacheStore

Complexity

Total Complexity

40

Size/Duplication

Total Lines	371
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	flushCache()	0	6	1
A	putCache()	0	12	1
A	setMessage()	0	4	1
A	isExpired()	0	5	2
A	getCache()	0	18	3
A	isSuccess()	0	3	1
A	serialize()	0	3	2
A	getMany()	0	7	2
A	forever()	0	4	1
A	handleCacheNotFound()	0	4	1
A	getMessage()	0	3	1
A	renewCache()	0	9	3
A	__construct()	0	3	1
A	has()	0	4	2
A	increment()	0	11	3
A	clearCache()	0	6	1
A	handleCacheExpired()	0	12	2
A	decrement()	0	3	1
A	appendCache()	0	13	2
A	buildArrayKey()	0	3	2
A	getAll()	0	9	4
A	putMany()	0	11	3

<?php

namespace Silviooosilva\CacheerPhp\CacheStore;

use Silviooosilva\CacheerPhp\Utils\CacheLogger;
use Silviooosilva\CacheerPhp\Interface\CacheerInterface;

/**
 * Class ArrayCacheStore
 * @author Sílvio Silva <https://github.com/silviooosilva>
 * @package Silviooosilva\CacheerPhp
 */
class ArrayCacheStore implements CacheerInterface
{

  /**
  * @param array $arrayStore
  */
  private array $arrayStore = [];

  /**
   * @param boolean
   */
  private bool $success = false;

  /**
   * @param string
   */
  private string $message = '';

  /**
   * @var CacheLogger
   */
  private $logger = null;

  /**
   * ArrayCacheStore constructor.
   * 
   * @param string $logPath
   */
  public function __construct(string $logPath)
  {
    $this->logger = new CacheLogger($logPath);
  }

  /**
   * Appends data to an existing cache item.
   * 
   * @param string $cacheKey
   * @param mixed  $cacheData
   * @param string $namespace
   * @return bool
   */
  public function appendCache(string $cacheKey, mixed $cacheData, string $namespace = '')
  {
      $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

      if (!$this->has($cacheKey, $namespace)) {
          $this->setMessage("cacheData can't be appended, because doesn't exist or expired", false);
          $this->logger->debug("{$this->getMessage()} from array driver.");
          return false;
      }

      $this->arrayStore[$arrayStoreKey]['cacheData'] = serialize($cacheData);
      $this->setMessage("Cache appended successfully", true);
      return true;
  }

  /**
   * Builds a unique key for the array store.
   * 
   * @param string $cacheKey
   * @param string $namespace
   * @return string
   */
  private function buildArrayKey(string $cacheKey, string $namespace = '')
  {
    return !empty($namespace) ? ($namespace . ':' . $cacheKey) : $cacheKey;
  }

  /**
   * Clears a specific cache item.
   * 
   * @param string $cacheKey
   * @param string $namespace
   * @return void
   */
  public function clearCache(string $cacheKey, string $namespace = '')
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
    unset($this->arrayStore[$arrayStoreKey]);
    $this->setMessage("Cache cleared successfully", true);
    $this->logger->debug("{$this->getMessage()} from array driver.");
  }

  /**
   * Decrements a cache item by a specified amount.
   * 
   * @param string $cacheKey
   * @param int $amount
   * @param string $namespace
   * @return bool
   */
  public function decrement(string $cacheKey, int $amount = 1, string $namespace = '')
  {
    return $this->increment($cacheKey, ($amount * -1), $namespace);
  }

  /**
   * Flushes all cache items.
   * 
   * @return void
   */
  public function flushCache()
  {
    unset($this->arrayStore);
    $this->arrayStore = [];
    $this->setMessage("Cache flushed successfully", true);
    $this->logger->debug("{$this->getMessage()} from array driver.");
  }

  /**
   * Stores a cache item permanently.
   * 
   * @param string $cacheKey
   * @param mixed $cacheData
   * @param string $namespace
   * @param int|string $ttl
   * @return void
   */
  public function forever(string $cacheKey, mixed $cacheData)
  {
    $this->putCache($cacheKey, $cacheData, ttl: 31536000 * 1000);
    $this->setMessage($this->getMessage(), $this->isSuccess());
  }

  /**
   * Retrieves a single cache item.
   * 
   * @param string $cacheKey
   * @param string $namespace
   * @param int|string $ttl
   * @return mixed
   */
  public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

    if (!$this->has($cacheKey, $namespace)) {
      $this->handleCacheNotFound();
      return false;
    }

    $cacheData = $this->arrayStore[$arrayStoreKey];
    if ($this->isExpired($cacheData)) {
      $this->handleCacheExpired($arrayStoreKey);
      return false;
    }

    $this->setMessage("Cache retrieved successfully", true);
    $this->logger->debug("{$this->getMessage()} from array driver.");
    return $this->serialize($cacheData['cacheData'], false);
  }

  /**
   * Verify if the cache is expired.
   * 
   * @param array $cacheData
   * @return bool
   */
  private function isExpired(array $cacheData): bool
  {
    $expirationTime = $cacheData['expirationTime'] ?? 0;
    $now = time();
    return $expirationTime !== 0 && $now >= $expirationTime;
  }

  /**
   * Handles the case when cache data is not found.
   * 
   * @return void
   */
  private function handleCacheNotFound()
  {
    $this->setMessage("cacheData not found, does not exists or expired", false);
    $this->logger->debug("{$this->getMessage()} from array driver.");
  }

  /**
   * Handles the case when cache data has expired.
   * 
   * @param string $arrayStoreKey
   * @return void
   */
  private function handleCacheExpired(string $arrayStoreKey)
  {
    $parts = explode(':', $arrayStoreKey, 2);
    if (count($parts) === 2) {
      list($np, $key) = $parts;
    } else {
      $np = '';
      $key = $arrayStoreKey;
    }
    $this->clearCache($key, $np);
    $this->setMessage("cacheKey: {$key} has expired.", false);
    $this->logger->debug("{$this->getMessage()} from array driver.");
  }

  /**
   * Gets all items in a specific namespace.
   * 
   * @param string $namespace
   * @return array
   */
  public function getAll(string $namespace = '')
  {
    $results = [];
    foreach ($this->arrayStore as $key => $data) {
      if (strpos($key, $namespace . ':') === 0 || empty($namespace)) {
        $results[$key] = $this->serialize($data['cacheData'], false);
      }
    }
    return $results;

The expression return $results returns the type array which is incompatible with the return type mandated by Silviooosilva\CacheerPhp\Interface\CacheerInterface::getAll() of Silviooosilva\CacheerPhp\Interface\CacheDataFormatter.

  }

  /**
   * Retrieves multiple cache items by their keys.
   * 
   * @param array $cacheKeys
   * @param string $namespace
   * @param string|int $ttl
   * @return array
   */
  public function getMany(array $cacheKeys, string $namespace = '', string|int $ttl = 3600)
  {
    $results = [];
    foreach ($cacheKeys as $cacheKey) {
      $results[$cacheKey] = $this->getCache($cacheKey, $namespace, $ttl);
    }
    return $results;

The expression return $results returns the type array which is incompatible with the return type mandated by Silviooosilva\CacheerPhp\Interface\CacheerInterface::getMany() of Silviooosilva\CacheerPhp\Interface\CacheDataFormatter.

  }

  /**
   * Checks if a cache item exists.
   * 
   * @param string $cacheKey
   * @param string $namespace
   * @return bool
   */
  public function has(string $cacheKey, string $namespace = '')
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
    return isset($this->arrayStore[$arrayStoreKey]) && time() < $this->arrayStore[$arrayStoreKey]['expirationTime'];
  }

  /**
   * Increments a cache item by a specified amount.
   * 
   * @param string $cacheKey
   * @param int $amount
   * @param string $namespace
   * @return bool
   */
  public function increment(string $cacheKey, int $amount = 1, string $namespace = '')
  {
    $cacheData = $this->getCache($cacheKey, $namespace);

    if(!empty($cacheData) && is_numeric($cacheData)) {
      $this->putCache($cacheKey, (int)($cacheData + $amount), $namespace);
      $this->setMessage($this->getMessage(), $this->isSuccess());
      return true;
    }

    return false;
  }

  /**
   * Checks if the operation was successful.
   * 
   * @return boolean
   */
  public function isSuccess()
  {
    return $this->success;
  }

  /**
   * Gets the last message.
   * 
   * @return string
   */
  public function getMessage()
  {
    return $this->message;
  }

  /**
   * Stores an item in the cache with a specific TTL.
   * 
   * @param string $cacheKey
   * @param mixed $cacheData
   * @param string $namespace
   * @param int|string $ttl
   * @return bool
   */
  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

    $this->arrayStore[$arrayStoreKey] = [
      'cacheData' => serialize($cacheData),
      'expirationTime' => time() + $ttl
    ];

    $this->setMessage("Cache stored successfully", true);
    $this->logger->debug("{$this->getMessage()} from Array driver.");
    return true;
  }

  /**
   * Stores multiple items in the cache in batches.
   * 
   * @param array $items
   * @param string $namespace
   * @param int $batchSize
   * @return void
   */
  public function putMany(array $items, string $namespace = '', int $batchSize = 100)
  {
    $chunks = array_chunk($items, $batchSize, true);

    foreach ($chunks as $chunk) {
      foreach ($chunk as $key => $data) {
          $this->putCache($data['cacheKey'], $data['cacheData'], $namespace);
        }
      }
    $this->setMessage("{$this->getMessage()}", $this->isSuccess());
    $this->logger->debug("{$this->getMessage()} from Array driver.");
  }

  /**
   * Renews the expiration time of a cache item.
   * 
   * @param string $cacheKey
   * @param string|int $ttl
   * @param string $namespace
   * @return void
   */
  public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

    if (isset($this->arrayStore[$arrayStoreKey])) {
        $ttlSeconds = is_numeric($ttl) ? (int) $ttl : strtotime($ttl) - time();
        $this->arrayStore[$arrayStoreKey]['expirationTime'] = time() + $ttlSeconds;
        $this->setMessage("cacheKey: {$cacheKey} renewed successfully", true);
        $this->logger->debug("{$this->getMessage()} from array driver.");
      }
  }

  /**
   * Sets a message and its success status.
   * 
   * @param string  $message
   * @param boolean $success
   * @return void
   */
  private function setMessage(string $message, bool $success)
  {
    $this->message = $message;
    $this->success = $success;
  }

  /**
   * Serializes or unserializes data based on the flag.
   * 
   * @param mixed $data
   * @param bool $serialize
   * @return mixed
   */
  private function serialize(mixed $data, bool $serialize = true)
  {
    return $serialize ? serialize($data) : unserialize($data);
  }
}