silviooosilva / CacheerPHP

src/CacheStore/ArrayCacheStore.php

Indentation +128 added lines, -128 removed lines

@@ -13,10 +13,10 @@ 
 class ArrayCacheStore implements CacheerInterface
 {
 
-  /**
-  * @param array $arrayStore
-  */
-  private array $arrayStore = [];
+    /**
+     * @param array $arrayStore
+     */
+    private array $arrayStore = [];
 
     /**
      * @param boolean
@@ -33,26 +33,26 @@ 
      */
     private $logger = null;
 
-  public function __construct(string $logPath)
-  {
+    public function __construct(string $logPath)
+    {
     $this->logger = new CacheLogger($logPath);
-  }
+    }
 
-  /**
-  * @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];
@@ -60,107 +60,107 @@ 
     $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['value'], false);
-  }
-
-  /**
-  * @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] = [
-      'value' => serialize($cacheData),
-      'expirationTime' => time() + $ttl
+        'value' => 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 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;
-      }
-
-      $currentValue = $this->arrayStore[$arrayStoreKey]['value'];
-      if (is_string($currentValue)) {
-          $currentValue = unserialize($currentValue);
-      }
-
-      $this->arrayStore[$arrayStoreKey]['value'] = serialize($cacheData);
-      $this->setMessage("Cache appended successfully", true);
-      return true;
-  }
-
-
-
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @return bool
-  */
-  public function has(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;
+        }
+
+        $currentValue = $this->arrayStore[$arrayStoreKey]['value'];
+        if (is_string($currentValue)) {
+            $currentValue = unserialize($currentValue);
+        }
+
+        $this->arrayStore[$arrayStoreKey]['value'] = serialize($cacheData);
+        $this->setMessage("Cache appended successfully", true);
+        return true;
+    }
+
+
+
+    /**
+     * @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|string $ttl
-  * @param string $namespace
-  * @return void
-  */
-  public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
-  {
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param int|string $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])) {
@@ -168,33 +168,33 @@ 
         $this->arrayStore[$arrayStoreKey]['expirationTime'] = time() + $ttlSeconds;
         $this->setMessage("cacheKey: {$cacheKey} renewed successfully", true);
         $this->logger->debug("{$this->getMessage()} from array driver.");
-      }
-  }
+        }
+    }
   
-  /**
-  * @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.");
 
-  }
+    }
 
-  /**
-  * @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  $message
@@ -224,24 +224,24 @@ 
         return $this->success;
     }
 
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @return string
-  */
-  private function buildArrayKey(string $cacheKey, string $namespace = '')
-  {
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @return string
+     */
+    private function buildArrayKey(string $cacheKey, string $namespace = '')
+    {
     return !empty($namespace) ? ($namespace . ':' . $cacheKey) : $cacheKey;
-  }
-
-  /**
-  * @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);
-  }
+    }
 
 }

Spacing +5 added lines, -5 removed lines

@@ -44,7 +44,7 @@ 
   * @param int|string $ttl
   * @return mixed
   */
-  public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
+  public function getCache(string $cacheKey, string $namespace = '', string | int $ttl = 3600)
   {
 
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
@@ -59,7 +59,7 @@ 
     $expirationTime = $cacheData['expirationTime'] ?? 0;
     $now = time();
 
-    if($expirationTime !== 0 && $now >= $expirationTime) {
+    if ($expirationTime !== 0 && $now >= $expirationTime) {
       list($np, $key) = explode(':', $arrayStoreKey);
       $this->clearCache($key, $np);
       $this->setMessage("cacheKey: {$key} has expired.", false);
@@ -79,7 +79,7 @@ 
   * @param int|string $ttl
   * @return bool
   */
-  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
+  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int | string $ttl = 3600)
   {
 
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
@@ -159,12 +159,12 @@ 
   * @param string $namespace
   * @return void
   */
-  public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
+  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();
+        $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.");

src/Utils/CacheDriver.php

Indentation +9 added lines, -9 removed lines

@@ -65,8 +65,8 @@ 
     }
 
     /**
-    * @return Cacheer
-    */
+     * @return Cacheer
+     */
     public function useArrayDriver()
     {
         $this->cacheer->cacheStore = new ArrayCacheStore($this->logPath);
@@ -92,14 +92,14 @@ 
     }
 
     /**
-    * @param mixed $dirName
-    * @return bool
-    */
+     * @param mixed $dirName
+     * @return bool
+     */
     private function isDir(mixed $dirName)
     {
-      if (is_dir($dirName)) {
-          return true;
-      }
-      return mkdir($dirName, 0755, true);
+        if (is_dir($dirName)) {
+            return true;
+        }
+        return mkdir($dirName, 0755, true);
     }
 }

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 @@ 
     $hasCache = $this->cache->has($cacheKey);
 
     $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 testRenewCacheWithNamespaceFromRedis()
-  {
+        public function testRenewCacheWithNamespaceFromRedis()
+    {
     $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 testClearCacheDataFromRedis()
     {
@@ -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;

Spacing +4 added lines, -4 removed lines

@@ -258,13 +258,13 @@ 
     {
         $this->cache->flushCache();
 
-        $value = $this->cache->remember('remember_test_key', 60, function () {
+        $value = $this->cache->remember('remember_test_key', 60, function() {
             return 'valor_teste';
         });
 
         $this->assertEquals('valor_teste', $value);
 
-        $cachedValue = $this->cache->remember('remember_test_key', 60, function (){
+        $cachedValue = $this->cache->remember('remember_test_key', 60, function() {
             return 'novo_valor';
         });
 
@@ -276,12 +276,12 @@ 
     {
         $this->cache->flushCache();
 
-        $value = $this->cache->rememberForever('remember_forever_key', function () {
+        $value = $this->cache->rememberForever('remember_forever_key', function() {
             return 'valor_eterno';
         });
         $this->assertEquals('valor_eterno', $value);
 
-        $cachedValue = $this->cache->rememberForever('remember_forever_key', function () {
+        $cachedValue = $this->cache->rememberForever('remember_forever_key', function() {
             return 'novo_valor';
         });