silviooosilva / CacheerPHP

src/Exceptions/CacheDatabaseException.php

Indentation +26 added lines, -26 removed lines

@@ -7,39 +7,39 @@ 
 class CacheDatabaseException extends BaseException
 {
 
-  /** @param string $before */
-  private static string $before = "<Database Cache Store Exception>";
+    /** @param string $before */
+    private static string $before = "<Database Cache Store Exception>";
 
-  /**
-   * @param string $message
-   * @param int $code
-   * @param Exception|null $previous
-   * @param array $details
-   * @return self
-   */
-  public static function create(string $message = "", int $code = 0, ?Exception $previous = null, array $details = [])
-  {
+    /**
+     * @param string $message
+     * @param int $code
+     * @param Exception|null $previous
+     * @param array $details
+     * @return self
+     */
+    public static function create(string $message = "", int $code = 0, ?Exception $previous = null, array $details = [])
+    {
     return new self(self::getBefore() . ": " .$message, $code, $previous, $details);
-  }
+    }
 
 
-  /**
-  * @return string
-  */
-  public static function getBefore(): string
-  {
+    /**
+     * @return string
+     */
+    public static function getBefore(): string
+    {
     return self::$before;
-  }
+    }
 
-  /**
-  * @return void
-  */
-  public static function setBefore(string $text): void
-  {
+    /**
+     * @return void
+     */
+    public static function setBefore(string $text): void
+    {
     self::$before = $text;
-  }
+    }
 
-   /*
+    /*
     * @return array
     */
     public function toArray()
@@ -61,6 +61,6 @@ 
      */
     public function toJson(int $options = 0)
     {
-      return parent::toJson($options);
+        return parent::toJson($options);
     }
 }

src/CacheStore/CacheManager/FileCacheManager.php

Indentation +22 added lines, -22 removed lines

@@ -15,9 +15,9 @@ 
 {
 
     /**
-    * @param string $dir
-    * @return void
-    */
+     * @param string $dir
+     * @return void
+     */
     public function createDirectory(string $dir)
     {
         if ((!file_exists($dir) || !is_dir($dir)) && !mkdir($dir, 0755, true)) {
@@ -26,10 +26,10 @@ 
     }
 
     /**
-    * @param string $filename
-    * @param string $data
-    * @return void
-    */
+     * @param string $filename
+     * @param string $data
+     * @return void
+     */
     public function writeFile(string $filename, string $data)
     {
         if (!@file_put_contents($filename, $data, LOCK_EX)) {
@@ -38,9 +38,9 @@ 
     }
 
     /**
-    * @param string $filename
-    * @return string
-    */
+     * @param string $filename
+     * @return string
+     */
     public function readFile(string $filename)
     {
         if (!$this->fileExists($filename)) {
@@ -50,18 +50,18 @@ 
     }
 
     /**
-    * @param string $filename
-    * @return bool
-    */
+     * @param string $filename
+     * @return bool
+     */
     public function fileExists(string $filename)
     {
         return file_exists($filename);
     }
 
     /**
-    * @param string $filename
-    * @return void
-    */
+     * @param string $filename
+     * @return void
+     */
     public function removeFile(string $filename)
     {
         if (file_exists($filename)) {
@@ -70,9 +70,9 @@ 
     }
 
     /**
-    * @param string $dir
-    * @return void
-    */
+     * @param string $dir
+     * @return void
+     */
     public function clearDirectory(string $dir)
     {
         $iterator = new RecursiveIteratorIterator(
@@ -86,9 +86,9 @@ 
     }
 
     /**
-    * @param mixed $data
-    * @param bool $serialize
-    */
+     * @param mixed $data
+     * @param bool $serialize
+     */
     public function serialize(mixed $data, bool $serialize = true)
     {
         if($serialize) {

src/CacheStore/ArrayCacheStore.php

Indentation +196 added lines, -196 removed lines

@@ -13,124 +13,124 @@ 
 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;
-
-  public function __construct(string $logPath)
-  {
+    /**
+     * @param array $arrayStore
+     */
+    private array $arrayStore = [];
+
+    /**
+     * @param boolean
+     */
+    private bool $success = false;
+
+    /**
+     * @param string
+     */
+    private string $message = '';
+
+    /**
+     * @var CacheLogger
+     */
+    private $logger = null;
+
+    public function __construct(string $logPath)
+    {
     $this->logger = new CacheLogger($logPath);
-  }
-
-  /**
-   * @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;
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param string $namespace
-   * @return string
-   */
-  private function buildArrayKey(string $cacheKey, string $namespace = '')
-  {
+    }
+
+    /**
+     * @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;
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @return string
+     */
+    private function buildArrayKey(string $cacheKey, string $namespace = '')
+    {
     return !empty($namespace) ? ($namespace . ':' . $cacheKey) : $cacheKey;
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param string $namespace
-   * @return void
-   */
-  public function clearCache(string $cacheKey, string $namespace = '')
-  {
+    }
+
+    /**
+     * @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.");
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param int $amount
-   * @param string $namespace
-   * @return bool
-   */
-  public function decrement(string $cacheKey, int $amount = 1, string $namespace = '')
-  {
+    }
+
+    /**
+     * @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);
-  }
+    }
 
-  /**
-   * @return void
-   */
-  public function flushCache()
-  {
+    /**
+     * @return void
+     */
+    public function flushCache()
+    {
     unset($this->arrayStore);
     $this->arrayStore = [];
     $this->setMessage("Cache flushed successfully", true);
     $this->logger->debug("{$this->getMessage()} from array driver.");
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param mixed $cacheData
-   * @param string $namespace
-   * @param int|string $ttl
-   * @return void
-   */
-  public function forever(string $cacheKey, mixed $cacheData)
-  {
+    }
+
+    /**
+     * @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());
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param string $namespace
-   * @param int|string $ttl
-   * @return mixed
-   */
-  public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
-  {
+    }
+
+    /**
+     * @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->setMessage("cacheData not found, does not exists or expired", false);
-      $this->logger->debug("{$this->getMessage()} from array driver.");
-      return false;
+        $this->setMessage("cacheData not found, does not exists or expired", false);
+        $this->logger->debug("{$this->getMessage()} from array driver.");
+        return false;
     }
 
     $cacheData = $this->arrayStore[$arrayStoreKey];
@@ -138,112 +138,112 @@ 
     $now = time();
 
     if($expirationTime !== 0 && $now >= $expirationTime) {
-      list($np, $key) = explode(':', $arrayStoreKey);
-      $this->clearCache($key, $np);
-      $this->setMessage("cacheKey: {$key} has expired.", false);
-      $this->logger->debug("{$this->getMessage()} from array driver.");
-      return false;
+        list($np, $key) = explode(':', $arrayStoreKey);
+        $this->clearCache($key, $np);
+        $this->setMessage("cacheKey: {$key} has expired.", false);
+        $this->logger->debug("{$this->getMessage()} from array driver.");
+        return false;
     }
 
     $this->setMessage("Cache retrieved successfully", true);
     $this->logger->debug("{$this->getMessage()} from array driver.");
     return $this->serialize($cacheData['cacheData'], false);
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param string $namespace
-   * @return bool
-   */
-  public function has(string $cacheKey, string $namespace = '')
-  {
+    }
+
+    /**
+     * @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'];
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param int $amount
-   * @param string $namespace
-   * @return bool
-   */
-  public function increment(string $cacheKey, int $amount = 1, string $namespace = '')
-  {
+    }
+
+    /**
+     * @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;
+        $this->putCache($cacheKey, (int)($cacheData + $amount), $namespace);
+        $this->setMessage($this->getMessage(), $this->isSuccess());
+        return true;
     }
 
     return false;
-  }
+    }
 
-  /**
-   * @return boolean
-   */
-  public function isSuccess()
-  {
+    /**
+     * @return boolean
+     */
+    public function isSuccess()
+    {
     return $this->success;
-  }
+    }
 
-  /**
-   * @return string
-   */
-  public function getMessage()
-  {
+    /**
+     * @return string
+     */
+    public function getMessage()
+    {
     return $this->message;
-  }
-
-  /**
-   * @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)
-  {
+    }
+
+    /**
+     * @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
+        'cacheData' => serialize($cacheData),
+        'expirationTime' => time() + $ttl
     ];
 
     $this->setMessage("Cache stored successfully", true);
     $this->logger->debug("{$this->getMessage()} from Array driver.");
     return true;
-  }
-
-  /**
-   * @param array $items
-   * @param string $namespace
-   * @param int $batchSize
-   * @return void
-   */
-  public function putMany(array $items, string $namespace = '', int $batchSize = 100)
-  {
+    }
+
+    /**
+     * @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);
+        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.");
-  }
-
-  /**
-   * @param string $cacheKey
-   * @param string|int $ttl
-   * @param string $namespace
-   * @return void
-   */
-  public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
-  {
+    }
+
+    /**
+     * @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])) {
@@ -251,27 +251,27 @@ 
         $this->arrayStore[$arrayStoreKey]['expirationTime'] = time() + $ttlSeconds;
         $this->setMessage("cacheKey: {$cacheKey} renewed successfully", true);
         $this->logger->debug("{$this->getMessage()} from array driver.");
-      }
-  }
-
-  /**
-   * @param string  $message
-   * @param boolean $success
-   * @return void
-   */
-  private function setMessage(string $message, bool $success)
-  {
+        }
+    }
+
+    /**
+     * @param string  $message
+     * @param boolean $success
+     * @return void
+     */
+    private function setMessage(string $message, bool $success)
+    {
     $this->message = $message;
     $this->success = $success;
-  }
-
-  /**
-   * @param mixed $data
-   * @param bool $serialize
-   * @return mixed
-   */
-  private function serialize(mixed $data, bool $serialize = true)
-  {
+    }
+
+    /**
+     * @param mixed $data
+     * @param bool $serialize
+     * @return mixed
+     */
+    private function serialize(mixed $data, bool $serialize = true)
+    {
     return $serialize ? serialize($data) : unserialize($data);
-  }
+    }
 }

src/Exceptions/ConnectionException.php

Indentation +1 added lines, -1 removed lines

@@ -58,7 +58,7 @@
      */
     public function toJson(int $options = 0)
     {
-      return parent::toJson($options);
+        return parent::toJson($options);
     }
 }
 

src/Exceptions/CacheFileException.php

Indentation +1 added lines, -1 removed lines

@@ -58,7 +58,7 @@
      */
     public function toJson(int $options = 0)
     {
-      return parent::toJson($options);
+        return parent::toJson($options);
     }
 }
 

tests/Unit/ArrayCacheStoreTest.php

Indentation +40 added lines, -40 removed lines

@@ -7,40 +7,40 @@ 
 class ArrayCacheStoreTest extends TestCase
 {
 
-  private $cache;
+    private $cache;
 
-  protected function setUp(): void
-  {
+    protected function setUp(): void
+    {
     $this->cache = new Cacheer();
     $this->cache->setDriver()->useArrayDriver();
     $this->cache->setConfig()->setTimeZone('America/Toronto');
-  }
+    }
 
-  protected function tearDown(): void
-  {
+    protected function tearDown(): void
+    {
     $this->cache->flushCache();
-  }
+    }
 
     public function testUsingArrayDriverSetsProperInstance()
-  {
+    {
     $this->assertInstanceOf(ArrayCacheStore::class, $this->cache->cacheStore);
-  }
+    }
 
-  public function testPutAndGetCacheInArray()
-  {
-      $cacheKey = 'test_key';
-      $cacheData = ['name' => 'John Doe', 'email' => 'john@example.com'];
+    public function testPutAndGetCacheInArray()
+    {
+        $cacheKey = 'test_key';
+        $cacheData = ['name' => 'John Doe', 'email' => 'john@example.com'];
       
-      $this->cache->putCache($cacheKey, $cacheData, '', 3600);
+        $this->cache->putCache($cacheKey, $cacheData, '', 3600);
 
-      $result = $this->cache->getCache($cacheKey);
+        $result = $this->cache->getCache($cacheKey);
 
-      $this->assertNotEmpty($result);
-      $this->assertEquals($cacheData, $result);
-  }
+        $this->assertNotEmpty($result);
+        $this->assertEquals($cacheData, $result);
+    }
 
-  public function testExpiredCacheInArray()
-  {
+    public function testExpiredCacheInArray()
+    {
     $cacheKey = 'expired_key';
     $cacheData = ['name' => 'Expired User', 'email' => 'expired@example.com'];
 
@@ -50,11 +50,11 @@ 
     $this->assertEquals("Cache stored successfully", $this->cache->getMessage());
     $this->assertEmpty($this->cache->getCache($cacheKey));
     $this->assertFalse($this->cache->isSuccess());
-  }
+    }
 
 
-  public function testOverwriteExistingCacheInArray()
-  {
+    public function testOverwriteExistingCacheInArray()
+    {
     $cacheKey = 'overwrite_key';
     $initialCacheData = ['name' => 'Initial Data', 'email' => 'initial@example.com'];
     $newCacheData = ['name' => 'New Data', 'email' => 'new@example.com'];
@@ -65,12 +65,12 @@ 
     $this->cache->appendCache($cacheKey, $newCacheData);
     $this->assertEquals("Cache appended successfully", $this->cache->getMessage());
     $this->assertEquals($newCacheData, $this->cache->getCache($cacheKey));
-  }
+    }
 
 
-  public function testPutManyCacheItemsInArray()
-  {
-     $items = [
+    public function testPutManyCacheItemsInArray()
+    {
+        $items = [
             [
                 'cacheKey' => 'user_1_profile',
                 'cacheData' => [
@@ -96,10 +96,10 @@ 
           
             $this->assertEquals($item['cacheData'], $this->cache->getCache($item['cacheKey']));
         }
-  }
+    }
 
-  public function testHasCacheFromArray()
-  {
+    public function testHasCacheFromArray()
+    {
     $cacheKey = 'test_key';
     $cacheData = ['name' => 'Sílvio Silva', 'role' => 'Developer'];
 
@@ -111,10 +111,10 @@ 
     $result = $this->cache->has($cacheKey);
     $this->assertTrue($result);
     $this->assertTrue($this->cache->isSuccess());
-  }
+    }
 
     public function testRenewCacheFromArray()
-  {
+    {
     $cacheKey = 'expired_key';
     $cacheData = ['name' => 'Expired User', 'email' => 'expired@example.com'];
 
@@ -129,10 +129,10 @@ 
     $this->cache->renewCache($cacheKey, 7200);
     $this->assertTrue($this->cache->isSuccess());
     $this->assertNotEmpty($this->cache->getCache($cacheKey));
-  }
+    }
 
-      public function testRenewCacheWithNamespaceFromArray()
-  {
+        public function testRenewCacheWithNamespaceFromArray()
+    {
     $cacheKey = 'expired_key';
     $namespace = 'expired_namespace';
     $cacheData = ['name' => 'Expired User', 'email' => 'expired@example.com'];
@@ -146,7 +146,7 @@ 
     $this->cache->renewCache($cacheKey, 7200, $namespace);
     $this->assertTrue($this->cache->isSuccess());
     $this->assertNotEmpty($this->cache->getCache($cacheKey, $namespace));
-  }
+    }
 
     public function testClearCacheDataFromArray()
     {
@@ -182,7 +182,7 @@ 
         $this->assertEquals("Cache flushed successfully", $this->cache->getMessage());
     }
 
-  public function test_remember_saves_and_recover_values() 
+    public function test_remember_saves_and_recover_values() 
     {
         $this->cache->flushCache();
 
@@ -217,7 +217,7 @@ 
     }
 
 
-      public function test_get_and_forget()
+        public function test_get_and_forget()
     {
         $cacheKey = 'cache_key_test';
         $this->cache->putCache($cacheKey, 10);
@@ -238,7 +238,7 @@ 
         $this->assertNull($noCacheData);
     }
 
-      public function test_store_if_not_present_with_add_function()
+        public function test_store_if_not_present_with_add_function()
     {
         $existentKey = 'cache_key_test';
 
@@ -262,7 +262,7 @@ 
 
     }
 
-      public function test_increment_function() {
+        public function test_increment_function() {
 
         $cacheKey = 'test_increment';
         $cacheData = 2025;