Merge pull request #104 from TheDragonCode/4.x

Added new `flexible()` method

Author: andrey-helldar

README.md

@@ -176,7 +176,12 @@ For example, `App\Models\Employee`, `App\Models\User`.
 ```php
 use DragonCode\Cache\Services\Cache;
 
-$cache = Cache::make()->key('foo', 'bar', ['baz', 'baq']);
+$cache = Cache::make()
+    ->key('foo', 'bar', ['baz', 'baq'])
+    ->ttl(200, true);
+    // When `true` is equal to 200 minutes.
+    // When `false` is equal to 200 seconds.
+    // By default, `true`
 
 $cache->put(static fn() => 'Some value');
 // or
@@ -193,6 +198,21 @@ $cache->rememberForever(static fn() => 'Some value');
 $cache->rememberForever('Some value');
 // Contains cached `Some value`
 
+// Uses the functionality of the `Cache::flexible()` method
+$cache->flexible(50)->remember('Some value');
+// equals `Cache::flexible($key, [50, 200], fn () => 'Some value')`
+
+$cache->flexible(-50)->remember('Some value');
+// equals `Cache::flexible($key, [150, 200], fn () => 'Some value')`
+
+$cache->flexible(0)->remember('Some value'); // By default, `0`
+// equals `Cache::flexible($key, [170, 200], fn () => 'Some value')`
+// (200 - 15%) = 170
+
+$cache->flexible(50, true); // 50 minutes
+$cache->flexible(50, false); // 50 seconds
+$cache->flexible(0, false); // the `true/false` modifier is not used
+
 $cache->get();
 // Returns cached `Some value`
 
@@ -232,6 +252,9 @@ $cache->rememberForever(static fn() => $user);
 $cache->rememberForever($user);
 // Contains cached `$user`
 
+$cache->flexible()->remember($user);
+// Returns User model with flexibility
+
 $cache->get();
 // Returns User model
 

composer.json

@@ -35,8 +35,8 @@
     "require": {
         "php": "^8.2",
         "dragon-code/support": "^6.11.3",
-        "illuminate/contracts": "^11.0 || ^12.0",
-        "illuminate/support": "^11.0 || ^12.0"
+        "illuminate/contracts": "^11.23 || ^12.0",
+        "illuminate/support": "^11.23 || ^12.0"
     },
     "require-dev": {
         "nesbot/carbon": "^2.62 || ^3.0",

src/Concerns/Call.php

@@ -17,7 +17,7 @@ protected function call(mixed $callback = null): mixed
         return is_callable($callback) && ! $this->isFunction($callback) ? $callback() : $callback;
     }
 
-    protected function makeCallable($value): callable
+    protected function makeCallable(mixed $value): callable
     {
         if (is_callable($value) && ! $this->isFunction($value)) {
             return $value;

src/Services/Cache.php

@@ -28,6 +28,8 @@ class Cache
 
     protected int $ttl = 86400;
 
+    protected ?int $ttlInterval = null;
+
     protected array $tags = [];
 
     protected mixed $key;
@@ -88,6 +90,44 @@ public function key(...$values): Cache
         return $this;
     }
 
+    /**
+     * It sets the time for stale of the key for its background update.
+     *
+     * > Note:
+     * >
+     * > This method works only in tandem with the `remember()` method.
+     *
+     * A positive value indicates the lifetime of the key before it stale.
+     * For example,
+     * ```
+     * Cache::flexible('some', [60, 300], fn () => ...)
+     * ```
+     *
+     * A negative value indicates the time the key will expire.
+     * For example,
+     * ```
+     * Cache::flexible('some', [300 - 60, 300], fn () => ...)
+     * ```
+     *
+     * If you specify 0, then 15% of the remaining time will be taken as the interval.
+     * For example,
+     * ```
+     * Cache::flexible('some', [(300 - 15% = 255), 300], fn () => ...)
+     * ```
+     *
+     * By default, `0`.
+     *
+     * @see https://laravel.com/docs/12.x/cache#swr
+     *
+     * @return $this
+     */
+    public function flexible(int $interval = 0, bool $isMinutes = true): Cache
+    {
+        $this->ttlInterval = $isMinutes ? $interval * 60 : $interval;
+
+        return $this;
+    }
+
     public function get(): mixed
     {
         return $this->manager()->get($this->getKey());
@@ -100,7 +140,9 @@ public function put(mixed $value): mixed
 
     public function remember(mixed $value): mixed
     {
-        return $this->manager()->remember($this->getKey(), $value, $this->ttl);
+        return $this->ttlInterval === null
+            ? $this->manager()->remember($this->getKey(), $value, $this->ttl)
+            : $this->manager()->flexible($this->getKey(), $value, $this->ttl, $this->ttlInterval);
     }
 
     public function rememberForever(mixed $value): mixed

src/Services/Storages/Disabled.php

@@ -16,6 +16,11 @@ public function put(string $key, $value, int $seconds): mixed
         return $this->get($key, $value);
     }
 
+    public function flexible(string $key, $value, int $seconds, int $interval): mixed
+    {
+        return $this->get($key, $value);
+    }
+
     public function remember(string $key, $value, int $seconds): mixed
     {
         return $this->get($key, $value);

src/Services/Storages/MainStore.php

@@ -26,6 +26,13 @@ public function put(string $key, $value, int $seconds): mixed
         return $value;
     }
 
+    public function flexible(string $key, $value, int $seconds, int $interval): mixed
+    {
+        $value = $this->makeCallable($value);
+
+        return Cache::flexible($key, [$seconds, $interval], $value);
+    }
+
     public function remember(string $key, $value, int $seconds): mixed
     {
         $value = $this->makeCallable($value);

src/Services/Storages/Store.php

@@ -12,6 +12,22 @@ abstract class Store
     use Call;
     use Makeable;
 
+    abstract public function flexible(string $key, $value, int $seconds, int $interval): mixed;
+
+    abstract public function flush(): void;
+
+    abstract public function forget(string $key): void;
+
+    abstract public function get(string $key, $default = null): mixed;
+
+    abstract public function has(string $key): bool;
+
+    abstract public function put(string $key, $value, int $seconds): mixed;
+
+    abstract public function remember(string $key, $value, int $seconds): mixed;
+
+    abstract public function rememberForever(string $key, $value): mixed;
+
     public function doesntHave(string $key): bool
     {
         return ! $this->has($key);

src/Services/Storages/TaggedStore.php

@@ -20,11 +20,8 @@ public function tags(array $tags): self
 
     public function get(string $key, $default = null): mixed
     {
-        if ($this->has($key)) {
-            return $this->cache()->get($key);
-        }
-
-        return $this->call($default);
+        return $this->cache()->get($key)
+            ?? $this->call($default);
     }
 
     public function put(string $key, $value, int $seconds): mixed
@@ -36,18 +33,19 @@ public function put(string $key, $value, int $seconds): mixed
         return $value;
     }
 
-    public function remember(string $key, $value, int $seconds): mixed
+    public function flexible(string $key, $value, int $seconds, int $interval): mixed
     {
-        $value = $this->makeCallable($value);
+        return $this->cache()->flexible($key, [$interval, $seconds], $this->makeCallable($value));
+    }
 
-        return $this->cache()->remember($key, $seconds, $value);
+    public function remember(string $key, $value, int $seconds): mixed
+    {
+        return $this->cache()->remember($key, $seconds, $this->makeCallable($value));
     }
 
     public function rememberForever(string $key, $value): mixed
     {
-        $value = $this->makeCallable($value);
-
-        return $this->cache()->rememberForever($key, $value);
+        return $this->cache()->rememberForever($key, $this->makeCallable($value));
     }
 
     public function forget(string $key): void

src/Support/CacheManager.php

@@ -43,6 +43,18 @@ public function put(string $key, $value, int $seconds): mixed
         return $this->instance()->put($key, $value, $seconds);
     }
 
+    public function flexible(string $key, $value, int $seconds, int $interval): mixed
+    {
+        if ($interval < 0) {
+            $interval = $seconds - $interval;
+        }
+        elseif ($interval === 0) {
+            $interval = (int) (300 * 0.85);
+        }
+
+        return $this->instance()->flexible($key, $value, $seconds, $interval);
+    }
+
     public function remember(string $key, $value, int $seconds): mixed
     {
         return $this->instance()->remember($key, $value, $seconds);

tests/Cache/NotWhen/Arrayables/Many/Arr/DragonCodeTest.php

@@ -4,6 +4,7 @@
 
 namespace Tests\Cache\NotWhen\Arrayables\Many\Arr;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use Tests\Cache\NotWhen\Base;
 use Tests\Fixtures\Many\DragonCodeArrayable;
 
@@ -36,6 +37,20 @@ public function testPut()
         $this->assertNull($this->cache()->get());
     }
 
+    #[DataProvider('booleanData')]
+    public function testFlexible(bool $isTrue)
+    {
+        $item = new DragonCodeArrayable();
+
+        $interval = $isTrue
+            ? $this->positiveTtlInterval
+            : $this->negativeTtlInterval;
+
+        $this->assertSame($item, $this->cache()->flexible($interval)->remember($item));
+
+        $this->assertNull($this->cache()->get());
+    }
+
     public function testRemember()
     {
         $item = new DragonCodeArrayable();