silviooosilva / CacheerPHP

Examples/example08.php

Indentation +3 added lines, -3 removed lines

@@ -23,15 +23,15 @@
     echo "Cache Found: ";
     print_r($Cacheer->getCache($cacheKey));
 } else {
-  echo $Cacheer->getMessage();
+    echo $Cacheer->getMessage();
 }
 
 // Renovando os dados do cache
 $Cacheer->renewCache($cacheKey, 3600);
 
 if($Cacheer->isSuccess()){
-  echo $Cacheer->getMessage() . PHP_EOL;
+    echo $Cacheer->getMessage() . PHP_EOL;
 } else {
-  echo $Cacheer->getMessage() . PHP_EOL;
+    echo $Cacheer->getMessage() . PHP_EOL;
 
 }
\ No newline at end of file

Examples/example07.php

Indentation +2 added lines, -2 removed lines

@@ -29,7 +29,7 @@ 
     echo "Cache Found: ";
     print_r($Cacheer->getCache($cacheKey));
 } else {
-  echo $Cacheer->getMessage();
+    echo $Cacheer->getMessage();
 }
 
 
@@ -40,6 +40,6 @@ 
     echo $Cacheer->getMessage() . PHP_EOL;
     print_r($Cacheer->getCache($cacheKey));
 } else {
-  echo $Cacheer->getMessage();
+    echo $Cacheer->getMessage();
 }
 

src/CacheStore/RedisCacheStore.php

Indentation +187 added lines, -187 removed lines

@@ -16,93 +16,93 @@ 
  */
 class RedisCacheStore implements CacheerInterface
 {
-  /** @var */
-  private $redis;
+    /** @var */
+    private $redis;
 
-  /** @param string $namespace */
-  private string $namespace = '';
+    /** @param string $namespace */
+    private string $namespace = '';
 
-  /**
-  * @var CacheLogger
-  */
-  private $logger = null;
+    /**
+     * @var CacheLogger
+     */
+    private $logger = null;
 
-  /**
-  * @var string
-  */
-  private string $message = '';
+    /**
+     * @var string
+     */
+    private string $message = '';
 
-  /**
-  * @var boolean
-  */
-  private bool $success = false;
+    /**
+     * @var boolean
+     */
+    private bool $success = false;
 
 
-  /**
-  * @return void
-  */
-  public function __construct(string $logPath)
-  {
+    /**
+     * @return void
+     */
+    public function __construct(string $logPath)
+    {
     $this->redis = RedisCacheManager::connect();
     $this->logger = new CacheLogger($logPath);
-  }
-
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @param string|int $ttl
-  * @return mixed
-  */
-  public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
-  {
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @param string|int $ttl
+     * @return mixed
+     */
+    public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
+    {
     $fullCacheKey = $this->buildKey($cacheKey, $namespace);
     $cacheData = $this->redis->get($fullCacheKey);
 
     if($cacheData) {
-      $this->setMessage("Cache retrieved successfully", true);
-      $this->logger->debug("{$this->getMessage()} from redis driver.");
-      return CacheRedisHelper::serialize($cacheData, false);
+        $this->setMessage("Cache retrieved successfully", true);
+        $this->logger->debug("{$this->getMessage()} from redis driver.");
+        return CacheRedisHelper::serialize($cacheData, false);
     }
 
     $this->setMessage("CacheData not found, does not exists or expired", false);
     $this->logger->info("{$this->getMessage()} from redis driver.");
-  }
-
-  /**
-  * Armazena um item no cache Redis, com suporte a namespace e TTL opcional.
-  *
-  * @param string $cacheKey
-  * @param mixed  $cacheData
-  * @param string $namespace
-  * @param string|int|null $ttl
-  * @return mixed
-  */
-  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', string|int|null $ttl = null)
-  {
-      $cacheFullKey = $this->buildKey($cacheKey, $namespace);
-      $serializedData = CacheRedisHelper::serialize($cacheData);
-
-      $result = $ttl ? $this->redis->setex($cacheFullKey, (int) $ttl, $serializedData) 
+    }
+
+    /**
+     * Armazena um item no cache Redis, com suporte a namespace e TTL opcional.
+     *
+     * @param string $cacheKey
+     * @param mixed  $cacheData
+     * @param string $namespace
+     * @param string|int|null $ttl
+     * @return mixed
+     */
+    public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', string|int|null $ttl = null)
+    {
+        $cacheFullKey = $this->buildKey($cacheKey, $namespace);
+        $serializedData = CacheRedisHelper::serialize($cacheData);
+
+        $result = $ttl ? $this->redis->setex($cacheFullKey, (int) $ttl, $serializedData) 
                     : $this->redis->set($cacheFullKey, $serializedData);
 
-      if ($result) {
-          $this->setMessage("Cache stored successfully", true);
-      } else {
-          $this->setMessage("Failed to store cache", false);
-      }
+        if ($result) {
+            $this->setMessage("Cache stored successfully", true);
+        } else {
+            $this->setMessage("Failed to store cache", false);
+        }
 
-      $this->logger->debug("{$this->getMessage()} from Redis driver.");
-      return $result;
-  }
+        $this->logger->debug("{$this->getMessage()} from Redis driver.");
+        return $result;
+    }
 
 
-  /**
-  * @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 = '')
+    {
     $cacheFullKey = $this->buildKey($cacheKey, $namespace);
 
 
@@ -114,107 +114,107 @@ 
 
 
     $this->logger->debug("{$this->getMessage()} from redis driver.");
-  }
-
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @return void
-  */
-  public function has(string $cacheKey, string $namespace = '')
-  {
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @return void
+     */
+    public function has(string $cacheKey, string $namespace = '')
+    {
     $cacheFullKey = $this->buildKey($cacheKey, $namespace);
 
     if($this->redis->exists($cacheFullKey) > 0) {
         $this->setMessage("Cache Key: {$cacheKey} exists!", true);
     } else {
         $this->setMessage("Cache Key: {$cacheKey} does not exists!", false);
-      }
+        }
 
     $this->logger->debug("{$this->getMessage()} from redis driver.");
-  }
-
-  /**
-  * @param string $cacheKey
-  * @param string|int $ttl
-  * @param string $namespace
-  * @return void
-  */
-  public function renewCache(string $cacheKey, string|int $ttl, string $namespace = '')
-  {
-      $cacheFullKey = $this->buildKey($cacheKey, $namespace);
-      $dump = $this->getDump($cacheFullKey);
-
-      if (!$dump) {
-          $this->setMessage("Cache Key: {$cacheKey} not found.", false);
-          $this->logger->warning("{$this->getMessage()} from Redis driver.");
-          return;
-      }
-
-      $this->clearCache($cacheFullKey);
-
-      if ($this->restoreKey($cacheFullKey, $ttl, $dump)) {
-          $this->setMessage("Cache Key: {$cacheKey} renewed successfully.", true);
-          $this->logger->debug("{$this->getMessage()} from Redis driver.");
-      } else {
-          $this->setMessage("Failed to renew cache key: {$cacheKey}.", false);
-          $this->logger->error("{$this->getMessage()} from Redis driver.");
-      }
-  }
-
-
-  /**
-  * @param string $cacheKey
-  * @param mixed  $cacheData
-  * @param string $namespace
-  * @return void
-  */
-  public function appendCache(string $cacheKey, mixed $cacheData, string $namespace = '')
-  {
-      $cacheFullKey = $this->buildKey($cacheKey, $namespace);
-      $existingData = $this->getCache($cacheFullKey);
-
-      $mergedCacheData = CacheRedisHelper::arrayIdentifier($existingData, $cacheData);
-
-      $serializedData = CacheRedisHelper::serialize($mergedCacheData);
-
-      if ($this->redis->set($cacheFullKey, $serializedData)) {
-          $this->setMessage("Cache appended successfully", true);
-      } else {
-          $this->setMessage("Something went wrong. Please, try again.", false);
-      }
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param string|int $ttl
+     * @param string $namespace
+     * @return void
+     */
+    public function renewCache(string $cacheKey, string|int $ttl, string $namespace = '')
+    {
+        $cacheFullKey = $this->buildKey($cacheKey, $namespace);
+        $dump = $this->getDump($cacheFullKey);
+
+        if (!$dump) {
+            $this->setMessage("Cache Key: {$cacheKey} not found.", false);
+            $this->logger->warning("{$this->getMessage()} from Redis driver.");
+            return;
+        }
+
+        $this->clearCache($cacheFullKey);
+
+        if ($this->restoreKey($cacheFullKey, $ttl, $dump)) {
+            $this->setMessage("Cache Key: {$cacheKey} renewed successfully.", true);
+            $this->logger->debug("{$this->getMessage()} from Redis driver.");
+        } else {
+            $this->setMessage("Failed to renew cache key: {$cacheKey}.", false);
+            $this->logger->error("{$this->getMessage()} from Redis driver.");
+        }
+    }
+
+
+    /**
+     * @param string $cacheKey
+     * @param mixed  $cacheData
+     * @param string $namespace
+     * @return void
+     */
+    public function appendCache(string $cacheKey, mixed $cacheData, string $namespace = '')
+    {
+        $cacheFullKey = $this->buildKey($cacheKey, $namespace);
+        $existingData = $this->getCache($cacheFullKey);
+
+        $mergedCacheData = CacheRedisHelper::arrayIdentifier($existingData, $cacheData);
+
+        $serializedData = CacheRedisHelper::serialize($mergedCacheData);
+
+        if ($this->redis->set($cacheFullKey, $serializedData)) {
+            $this->setMessage("Cache appended successfully", true);
+        } else {
+            $this->setMessage("Something went wrong. Please, try again.", false);
+        }
 
   
-      $this->logger->debug("{$this->getMessage()} from redis driver.");
-  }
+        $this->logger->debug("{$this->getMessage()} from redis driver.");
+    }
 
 
-  /**
-  * @param array  $items
-  * @param string $namespace
-  * @param int    $batchSize
-  * @return void
-  */
-  public function putMany(array $items, string $namespace = '', int $batchSize = 100)
-  {
-      $processedCount = 0;
-      $itemCount = count($items);
+    /**
+     * @param array  $items
+     * @param string $namespace
+     * @param int    $batchSize
+     * @return void
+     */
+    public function putMany(array $items, string $namespace = '', int $batchSize = 100)
+    {
+        $processedCount = 0;
+        $itemCount = count($items);
 
-      while($processedCount < $itemCount)
-      {
+        while($processedCount < $itemCount)
+        {
 
         $batchItems = array_slice($items, $processedCount, $batchSize);
         $this->processBatchItems($batchItems, $namespace);
         $processedCount += count($batchItems);
-      }
+        }
 
-  }
+    }
 
-  /**
-  * @return void
-  */
-  public function flushCache()
-  {
+    /**
+     * @return void
+     */
+    public function flushCache()
+    {
   
     if($this->redis->flushall()) {
         $this->setMessage("Cache flushed successfully", true);
@@ -223,7 +223,7 @@ 
     }
 
     $this->logger->debug("{$this->getMessage()} from redis driver.");
-  }
+    }
 
     /**
      * @return string
@@ -241,17 +241,17 @@ 
         return $this->success;
     }
 
-  /**
-  * @param string $key
-  * @param string $namespace
-  * @return string
-  */
-  private function buildKey(string $key, string $namespace)
-  {
+    /**
+     * @param string $key
+     * @param string $namespace
+     * @return string
+     */
+    private function buildKey(string $key, string $namespace)
+    {
     return $this->namespace . ($namespace ? $namespace . ':' : '') . $key;
-  }
+    }
 
-  /**
+    /**
      * @param string  $message
      * @param boolean $success
      * @return void
@@ -263,10 +263,10 @@ 
     }
 
         /**
-     * @param array  $batchItems
-     * @param string $namespace
-     * @return void
-     */
+         * @param array  $batchItems
+         * @param string $namespace
+         * @return void
+         */
     private function processBatchItems(array $batchItems, string $namespace)
     {
         foreach($batchItems as $item) {
@@ -278,29 +278,29 @@ 
         }
     }
 
-      /**
-  * @param string $fullKey
-  * @return string|null
-  */
-  private function getDump(string $fullKey)
-  {
-      return $this->redis->dump($fullKey);
-  }
-
-
-  /**
-  * @param string $fullKey
-  * @param string|int $ttl
-  * @param mixed $dump
-  * @return bool
-  */
-  private function restoreKey(string $fullKey, string|int $ttl, mixed $dump)
-  {
-      try {
-          $this->redis->restore($fullKey, $ttl * 1000, $dump, 'REPLACE');
-          return true;
-      } catch (Exception $e) {
-          throw CacheRedisException::create($e->getMessage());
-      }
-  }
+        /**
+         * @param string $fullKey
+         * @return string|null
+         */
+    private function getDump(string $fullKey)
+    {
+        return $this->redis->dump($fullKey);
+    }
+
+
+    /**
+     * @param string $fullKey
+     * @param string|int $ttl
+     * @param mixed $dump
+     * @return bool
+     */
+    private function restoreKey(string $fullKey, string|int $ttl, mixed $dump)
+    {
+        try {
+            $this->redis->restore($fullKey, $ttl * 1000, $dump, 'REPLACE');
+            return true;
+        } catch (Exception $e) {
+            throw CacheRedisException::create($e->getMessage());
+        }
+    }
 }

src/Helpers/CacheRedisHelper.php

Indentation +66 added lines, -66 removed lines

@@ -12,20 +12,20 @@ 
 class CacheRedisHelper
 {
 
-  /**
-  * @param mixed $data
-  * @param bool  $serialize
-  * @return mixed
-  */
-  public static function serialize(mixed $data, bool $serialize = true)
-  {
+    /**
+     * @param mixed $data
+     * @param bool  $serialize
+     * @return mixed
+     */
+    public static function serialize(mixed $data, bool $serialize = true)
+    {
     if($serialize) {
-      return serialize($data);
+        return serialize($data);
     }
 
     return unserialize($data);
 
-  }
+    }
 
     /**
      * @param array $item
@@ -54,63 +54,63 @@ 
         return (array)$cacheData;
     }
 
-  /**
-    * @param mixed $currentCacheData
-    * @param mixed $cacheData
-    * @return array
-    */
-  public static function arrayIdentifier(mixed $currentCacheData, mixed $cacheData)
-  {
-      /**
-      * Se ambos forem arrays, mescle-os de forma recursiva para preservar subarrays
-      */
-      if (is_array($currentCacheData) && is_array($cacheData)) {
-          return self::mergeRecursive($currentCacheData, $cacheData);
-      }
-
-      /** 
-      * Se $currentCacheData não for um array, inicialize-o como um array vazio
-      */
-      if (!is_array($currentCacheData)) {
-          $currentCacheData = [];
-      }
-
-      /**
-      * Se $cacheData não for um array, converta-o em um array
-      */
-      if (!is_array($cacheData)) {
-          $cacheData = [$cacheData];
-      }
-
-      return array_merge($currentCacheData, $cacheData);
-  }
-
-  /**
-    * Mescla arrays de forma recursiva.
-    * @param array $array1
-    * @param array $array2
-    * @return array
-    */
-  private static function mergeRecursive(array $array1, array $array2)
-  {
-      foreach ($array2 as $key => $value) {
-
-          /**
-          * Se a chave existe em ambos os arrays e ambos os valores são arrays, mescle recursivamente
-          */
-          if (isset($array1[$key]) && is_array($array1[$key]) && is_array($value)) {
-              $array1[$key] = self::mergeRecursive($array1[$key], $value);
-          } else {
-
-              /**
-              * Caso contrário, sobrescreva o valor em $array1 com o valor de $array2
-              */
-              $array1[$key] = $value;
-          }
-      }
-
-      return $array1;
-  }
+    /**
+     * @param mixed $currentCacheData
+     * @param mixed $cacheData
+     * @return array
+     */
+    public static function arrayIdentifier(mixed $currentCacheData, mixed $cacheData)
+    {
+        /**
+         * Se ambos forem arrays, mescle-os de forma recursiva para preservar subarrays
+         */
+        if (is_array($currentCacheData) && is_array($cacheData)) {
+            return self::mergeRecursive($currentCacheData, $cacheData);
+        }
+
+        /** 
+         * Se $currentCacheData não for um array, inicialize-o como um array vazio
+         */
+        if (!is_array($currentCacheData)) {
+            $currentCacheData = [];
+        }
+
+        /**
+         * Se $cacheData não for um array, converta-o em um array
+         */
+        if (!is_array($cacheData)) {
+            $cacheData = [$cacheData];
+        }
+
+        return array_merge($currentCacheData, $cacheData);
+    }
+
+    /**
+     * Mescla arrays de forma recursiva.
+     * @param array $array1
+     * @param array $array2
+     * @return array
+     */
+    private static function mergeRecursive(array $array1, array $array2)
+    {
+        foreach ($array2 as $key => $value) {
+
+            /**
+             * Se a chave existe em ambos os arrays e ambos os valores são arrays, mescle recursivamente
+             */
+            if (isset($array1[$key]) && is_array($array1[$key]) && is_array($value)) {
+                $array1[$key] = self::mergeRecursive($array1[$key], $value);
+            } else {
+
+                /**
+                 * Caso contrário, sobrescreva o valor em $array1 com o valor de $array2
+                 */
+                $array1[$key] = $value;
+            }
+        }
+
+        return $array1;
+    }
 
 }
 

src/Exceptions/CacheRedisException.php

Indentation +20 added lines, -20 removed lines

@@ -8,34 +8,34 @@
 {
 
 
-  /** @param string $before */
-  private static string $before = "<Redis Cache Store Exception>";
+    /** @param string $before */
+    private static string $before = "<Redis Cache Store Exception>";
 
 
-  /**
-  * @return void
-  */
-  public static function create(string $message = "", int $code = 0, ?Exception $previous = null, array $details = [])
-  {
+    /**
+     * @return void
+     */
+    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()
-  {
+    /**
+     * @return string
+     */
+    public static function getBefore()
+    {
     return self::$before;
-  }
+    }
 
-  /**
-  * @return void
-  */
-  public static function setBefore(string $text)
-  {
+    /**
+     * @return void
+     */
+    public static function setBefore(string $text)
+    {
     self::$before = $text;
-  }
+    }
 
 }
 

src/Helpers/EnvHelper.php

Indentation +2 added lines, -2 removed lines

@@ -34,8 +34,8 @@
     }
 
     /**
-    * @return void
-    */
+     * @return void
+     */
     public static function copyEnv()
     {
         $rootDir = self::getRootPath();

src/CacheStore/CacheManager/FileCacheManager.php

Indentation +22 added lines, -22 removed lines

@@ -10,9 +10,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, 0777, true)) {
@@ -21,10 +21,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)) {
@@ -33,9 +33,9 @@ 
     }
 
     /**
-    * @param string $filename
-    * @return string
-    */
+     * @param string $filename
+     * @return string
+     */
     public function readFile(string $filename)
     {
         if (!$this->fileExists($filename)) {
@@ -45,18 +45,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)) {
@@ -65,9 +65,9 @@ 
     }
 
     /**
-    * @param string $dir
-    * @return void
-    */
+     * @param string $dir
+     * @return void
+     */
     public function clearDirectory(string $dir)
     {
         $iterator = new RecursiveIteratorIterator(
@@ -81,9 +81,9 @@ 
     }
 
     /**
-    * @param mixed $data
-    * @param bool $serealize
-    */
+     * @param mixed $data
+     * @param bool $serealize
+     */
     public function serialize(mixed $data, bool $serealize = true)
     {
         if($serealize) {

tests/Feature/OptionBuildTest.php

Indentation +38 added lines, -38 removed lines

@@ -7,26 +7,26 @@ 
 class OptionBuildTest extends TestCase
 {
 
-  private $cache;
-  private $cacheDir;
+    private $cache;
+    private $cacheDir;
 
-  protected function setUp(): void
-  {
+    protected function setUp(): void
+    {
     $this->cacheDir = __DIR__ . '/cache';
     if (!file_exists($this->cacheDir) || !is_dir($this->cacheDir)) {
-      mkdir($this->cacheDir, 0755, true);
+        mkdir($this->cacheDir, 0755, true);
     }
 
     $this->cache = new Cacheer();
-  }
+    }
 
-  protected function tearDown(): void
-  {
+    protected function tearDown(): void
+    {
     $this->cache->flushCache();
-  }
+    }
 
-  public function test_it_can_set_cache_diretory()
-  {
+    public function test_it_can_set_cache_diretory()
+    {
     $cacheDir = __DIR__ . "/cache";
 
     $options = OptionBuilder::forFile()
@@ -35,23 +35,23 @@ 
 
     $this->assertArrayHasKey('cacheDir', $options);
     $this->assertEquals($cacheDir, $options['cacheDir']);
-  }
+    }
 
 
-  public function test_it_can_set_expiration_time()
+    public function test_it_can_set_expiration_time()
     {
 
-      $options = OptionBuilder::forFile()
-      ->expirationTime('2 hours')
-      ->build();
+        $options = OptionBuilder::forFile()
+        ->expirationTime('2 hours')
+        ->build();
       
-      $this->assertArrayHasKey('expirationTime', $options);
-      $this->assertEquals('2 hours', $options['expirationTime']);
+        $this->assertArrayHasKey('expirationTime', $options);
+        $this->assertEquals('2 hours', $options['expirationTime']);
     }
 
     public function test_it_can_set_flush_after()
     {
-      $options = OptionBuilder::forFile()
+        $options = OptionBuilder::forFile()
         ->flushAfter('11 seconds')
         ->build();
 
@@ -61,9 +61,9 @@ 
 
     public function test_it_can_set_multiple_options_together()
     {
-      $cacheDir = __DIR__ . "/cache";
+        $cacheDir = __DIR__ . "/cache";
 
-      $options = OptionBuilder::forFile()
+        $options = OptionBuilder::forFile()
             ->dir($cacheDir)
             ->expirationTime('1 day')
             ->flushAfter('30 minutes')
@@ -76,41 +76,41 @@ 
         ], $options);
     }
 
-  public function test_it_allows_setting_expiration_time_with_timebuilder()
+    public function test_it_allows_setting_expiration_time_with_timebuilder()
     {
-      $options = OptionBuilder::forFile()->expirationTime()->week(1)->build();
-      $this->assertArrayHasKey('expirationTime', $options);
-      $this->assertEquals('1 weeks', $options['expirationTime']);
+        $options = OptionBuilder::forFile()->expirationTime()->week(1)->build();
+        $this->assertArrayHasKey('expirationTime', $options);
+        $this->assertEquals('1 weeks', $options['expirationTime']);
     }
 
-  public function test_it_allows_setting_flush_after_with_timebuilder()
-  {
+    public function test_it_allows_setting_flush_after_with_timebuilder()
+    {
     $options = OptionBuilder::forFile()->flushAfter()->second(10)->build();
     $this->assertArrayHasKey('flushAfter', $options);
     $this->assertEquals('10 seconds', $options['flushAfter']);
-  }
+    }
 
-  public function test_it_can_set_multiple_options_together_with_timebuilder()
-  {
+    public function test_it_can_set_multiple_options_together_with_timebuilder()
+    {
     $cacheDir = __DIR__ . "/cache";
     $options = OptionBuilder::forFile()
-          ->dir($cacheDir)
-          ->expirationTime()->week(1)
-          ->flushAfter()->minute(10)
-          ->build();
+            ->dir($cacheDir)
+            ->expirationTime()->week(1)
+            ->flushAfter()->minute(10)
+            ->build();
 
     $this->assertEquals([
             'cacheDir' => $cacheDir,
             'expirationTime' => '1 weeks',
             'flushAfter' => '10 minutes',
         ], $options);
-  }
+    }
 
-  public function test_it_returns_empty_array_when_no_options_are_set()
-  {
+    public function test_it_returns_empty_array_when_no_options_are_set()
+    {
     $options = OptionBuilder::forFile()->build();
     $this->assertIsArray($options);
     $this->assertEmpty($options);
-  }
+    }
 
 }

src/Config/Option/Builder/OptionBuilder.php

Indentation +5 added lines, -5 removed lines

@@ -11,10 +11,10 @@
  */
 class OptionBuilder
 {
-  /**
-  * @return FileOptionBuilder
-  */
-  public static function forFile() {
+    /**
+     * @return FileOptionBuilder
+     */
+    public static function forFile() {
     return new FileOptionBuilder();
-  }
+    }
 }