Merge pull request #2 from moufmouf/classBoundCache

Adding the notion of ClassBoundCache

Author: moufmouf

README.md

@@ -21,7 +21,7 @@ For instance, Doctrine Annotations in a class do not change unless the class fil
 sense to bind the cache invalidation to the modification date of the file. *thecodingmachine/cache-utils* provides just that.
 
 ```php
-namespace TheCodingMachine\CacheUtils\FileBoundCache;
+use TheCodingMachine\CacheUtils\FileBoundCache;
 
 $fileBoundCache = new FileBoundCache($psr16Cache);
 
@@ -40,8 +40,42 @@ $myDataToCache = $fileBoundCache->get('cache_key');
 You can also use the `MemoryAdapter` to store the cache in memory for even faster access in the same query.
 
 ```php
-namespace TheCodingMachine\CacheUtils\FileBoundCache;
-namespace TheCodingMachine\CacheUtils\MemoryAdapter;
+use TheCodingMachine\CacheUtils\FileBoundCache;
+use TheCodingMachine\CacheUtils\MemoryAdapter;
 
 $fileBoundCache = new MemoryAdapter(new FileBoundCache($psr16Cache));
 ```
+
+### Class bound cache
+
+You can also bind a cache item to a class / trait / interface using the `ClassBoundCache` class.
+The cache will expire if the class / trait / interface is modified.
+
+```php
+use TheCodingMachine\CacheUtils\FileBoundCache;
+use TheCodingMachine\CacheUtils\ClassBoundCache;
+
+$fileBoundCache = new FileBoundCache($psr16Cache);
+$classBoundCache = new ClassBoundCache($fileBoundCache);
+
+// Put the $myDataToCache object in cache.
+// If the FooBar class is modified, the cache item is purged.
+$classBoundCache->set('cache_key', $myDataToCache, FooBar::class);
+
+// Fetching data
+$myDataToCache = $classBoundCache->get('cache_key');
+```
+
+The `ClassBoundCache` constructor accepts 3 additional parameters:
+
+```php
+
+class ClassBoundCache implements ClassBoundCacheInterface
+{
+    public function __construct(FileBoundCacheInterface $fileBoundCache, bool $analyzeParentClasses = true, bool $analyzeTraits = true, bool $analyzeInterfaces = false)
+}
+```
+
+- `$analyzeParentClasses`: if set to true, the cache will be invalidated if one of the parent classes is modified
+- `$analyzeTraits`: if set to true, the cache will be invalidated if one of the traits is modified
+- `$analyzeInterfaces`: if set to true, the cache will be invalidated if one of the interfaces implemented is modified

src/ClassBoundCache.php

@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TheCodingMachine\CacheUtils;
+
+use ReflectionClass;
+use function array_merge;
+
+class ClassBoundCache implements ClassBoundCacheInterface
+{
+    /** @var FileBoundCacheInterface */
+    private $fileBoundCache;
+    /** @var bool */
+    private $analyzeParentClasses;
+    /** @var bool */
+    private $analyzeTraits;
+    /** @var bool */
+    private $analyzeInterfaces;
+
+    public function __construct(FileBoundCacheInterface $fileBoundCache, bool $analyzeParentClasses = true, bool $analyzeTraits = true, bool $analyzeInterfaces = false)
+    {
+        $this->fileBoundCache = $fileBoundCache;
+        $this->analyzeParentClasses = $analyzeParentClasses;
+        $this->analyzeTraits = $analyzeTraits;
+        $this->analyzeInterfaces = $analyzeInterfaces;
+    }
+
+    /**
+     * Fetches an element from the cache by key.
+     *
+     * @return mixed
+     */
+    public function get(string $key)
+    {
+        return $this->fileBoundCache->get($key);
+    }
+
+    /**
+     * Stores an item in the cache.
+     *
+     * @param mixed $item The item must be serializable.
+     * @param ReflectionClass $refClass If the class is modified, the cache item is invalidated.
+     */
+    public function set(string $key, $item, ReflectionClass $refClass, ?int $ttl = null): void
+    {
+        $files = $this->getFilesForClass($refClass);
+
+        $this->fileBoundCache->set($key, $item, $files, $ttl);
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function getFilesForClass(ReflectionClass $refClass): array
+    {
+        $files = [];
+        $file = $refClass->getFileName();
+        if ($file !== false) {
+            $files[] = $file;
+        }
+
+        if ($this->analyzeParentClasses && $refClass->getParentClass() !== false) {
+            $files = array_merge($files, $this->getFilesForClass($refClass->getParentClass()));
+        }
+
+        if ($this->analyzeTraits) {
+            foreach ($refClass->getTraits() as $trait) {
+                $files = array_merge($files, $this->getFilesForClass($trait));
+            }
+        }
+
+        if ($this->analyzeInterfaces) {
+            foreach ($refClass->getInterfaces() as $interface) {
+                $files = array_merge($files, $this->getFilesForClass($interface));
+            }
+        }
+
+        return $files;
+    }
+}

src/ClassBoundCacheInterface.php

@@ -4,6 +4,8 @@
 
 namespace TheCodingMachine\CacheUtils;
 
+use ReflectionClass;
+
 /**
  * Cache items. Items expiration is bound to the modification time of a PHP class.
  */
@@ -20,7 +22,7 @@ public function get(string $key);
      * Stores an item in the cache.
      *
      * @param mixed $item The item must be serializable.
-     * @param string $className Fully qualified class name.
+     * @param ReflectionClass $refClass If the class is modified, the cache item is invalidated.
      */
-    public function set(string $key, $item, string $className): void;
+    public function set(string $key, $item, ReflectionClass $refClass, ?int $ttl = null): void;
 }

tests/ClassBoundCacheTest.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace TheCodingMachine\CacheUtils;
+
+use function clearstatcache;
+use function file_get_contents;
+use function file_put_contents;
+use ReflectionClass;
+use function sleep;
+use function str_replace;
+use Symfony\Component\Cache\Simple\ArrayCache;
+use function sys_get_temp_dir;
+use PHPUnit\Framework\TestCase;
+use TheCodingMachine\CacheUtils\Fixtures\A;
+use TheCodingMachine\CacheUtils\Fixtures\B;
+use TheCodingMachine\CacheUtils\Fixtures\C;
+use TheCodingMachine\CacheUtils\Fixtures\D;
+use function touch;
+
+class ClassBoundCacheTest extends TestCase
+{
+    /**
+     * @dataProvider touchFile
+     */
+    public function testFileBoundCache($classToTouch)
+    {
+        $cache = new ArrayCache();
+        $fileBoundCache = new FileBoundCache($cache, 'prefix');
+        $classBoundCache = new ClassBoundCache($fileBoundCache, true, true, true);
+
+        $classBoundCache->set('foo', 'bar', new ReflectionClass(A::class));
+
+        $this->assertSame('bar', $classBoundCache->get('foo'));
+
+        $classToTouch = new ReflectionClass($classToTouch);
+        sleep(1);
+        clearstatcache($classToTouch->getFileName());
+        touch($classToTouch->getFileName());
+
+        $this->assertNull($classBoundCache->get('foo'));
+    }
+
+    public function touchFile()
+    {
+        return [
+            [ B::class ],
+            [ C::class ],
+            [ D::class ],
+        ];
+    }
+}

tests/Fixtures/A.php

@@ -0,0 +1,10 @@
+<?php
+
+
+namespace TheCodingMachine\CacheUtils\Fixtures;
+
+
+class A extends B
+{
+
+}

tests/Fixtures/B.php

@@ -0,0 +1,10 @@
+<?php
+
+
+namespace TheCodingMachine\CacheUtils\Fixtures;
+
+
+class B implements C
+{
+    use D;
+}

tests/Fixtures/C.php

@@ -0,0 +1,10 @@
+<?php
+
+
+namespace TheCodingMachine\CacheUtils\Fixtures;
+
+
+interface C
+{
+
+}

tests/Fixtures/D.php

@@ -0,0 +1,9 @@
+<?php
+
+
+namespace TheCodingMachine\CacheUtils\Fixtures;
+
+
+trait D
+{
+}