Do not store classesIn(), traitsIn(), functionsIn(), linesOfCodeFor(), and ignoredLinesFor() data in separate cache files

Author: sebastianbergmann

src/StaticAnalysis/Cache.php

@@ -42,13 +42,13 @@ public function __construct(string $directory, bool $validate = true)
         $this->validate  = $validate;
     }
 
-    protected function has(string $filename, string $method): bool
+    protected function has(string $filename, string $key): bool
     {
         if (!$this->validate) {
             return true;
         }
 
-        $cacheFile = $this->cacheFile($filename, $method);
+        $cacheFile = $this->cacheFile($filename, $key);
 
         if (!is_file($cacheFile)) {
             return false;
@@ -66,7 +66,7 @@ protected function has(string $filename, string $method): bool
      *
      * @return mixed
      */
-    protected function read(string $filename, string $method, array $allowedClasses = [])
+    protected function read(string $filename, string $key, array $allowedClasses = [])
     {
         $options = ['allowed_classes' => false];
 
@@ -76,7 +76,7 @@ protected function read(string $filename, string $method, array $allowedClasses
 
         return unserialize(
             file_get_contents(
-                $this->cacheFile($filename, $method)
+                $this->cacheFile($filename, $key)
             ),
             $options
         );
@@ -85,16 +85,16 @@ protected function read(string $filename, string $method, array $allowedClasses
     /**
      * @param mixed $data
      */
-    protected function write(string $filename, string $method, $data): void
+    protected function write(string $filename, string $key, $data): void
     {
         file_put_contents(
-            $this->cacheFile($filename, $method),
+            $this->cacheFile($filename, $key),
             serialize($data)
         );
     }
 
-    private function cacheFile(string $filename, string $method): string
+    private function cacheFile(string $filename, string $key): string
     {
-        return $this->directory . DIRECTORY_SEPARATOR . hash('sha256', $filename . $method);
+        return $this->directory . DIRECTORY_SEPARATOR . hash('sha256', $filename . $key);
     }
 }

src/StaticAnalysis/CacheWarmer.php

@@ -29,20 +29,7 @@ public function warmCache(string $cacheDirectory, bool $useAnnotationsForIgnorin
         );
 
         foreach ($filter->files() as $file) {
-            /* @noinspection UnusedFunctionResultInspection */
-            $coveredFileAnalyser->classesIn($file);
-
-            /* @noinspection UnusedFunctionResultInspection */
-            $coveredFileAnalyser->traitsIn($file);
-
-            /* @noinspection UnusedFunctionResultInspection */
-            $coveredFileAnalyser->functionsIn($file);
-
-            /* @noinspection UnusedFunctionResultInspection */
-            $coveredFileAnalyser->linesOfCodeFor($file);
-
-            /* @noinspection UnusedFunctionResultInspection */
-            $coveredFileAnalyser->ignoredLinesFor($file);
+            $coveredFileAnalyser->process($file);
 
             /* @noinspection UnusedFunctionResultInspection */
             $uncoveredFileAnalyser->executableLinesIn($file);

src/StaticAnalysis/CachingCoveredFileAnalyser.php

@@ -24,7 +24,7 @@ final class CachingCoveredFileAnalyser extends Cache implements CoveredFileAnaly
     /**
      * @var array
      */
-    private $inMemoryCacheForIgnoredLines = [];
+    private $cache = [];
 
     public function __construct(string $directory, CoveredFileAnalyser $coveredFileAnalyser, bool $validate = true)
     {
@@ -35,70 +35,65 @@ public function __construct(string $directory, CoveredFileAnalyser $coveredFileA
 
     public function classesIn(string $filename): array
     {
-        if ($this->has($filename, __METHOD__)) {
-            return $this->read($filename, __METHOD__);
+        if (!isset($this->cache[$filename])) {
+            $this->process($filename);
         }
 
-        $data = $this->coveredFileAnalyser->classesIn($filename);
-
-        $this->write($filename, __METHOD__, $data);
-
-        return $data;
+        return $this->cache[$filename]['classesIn'];
     }
 
     public function traitsIn(string $filename): array
     {
-        if ($this->has($filename, __METHOD__)) {
-            return $this->read($filename, __METHOD__);
+        if (!isset($this->cache[$filename])) {
+            $this->process($filename);
         }
 
-        $data = $this->coveredFileAnalyser->traitsIn($filename);
-
-        $this->write($filename, __METHOD__, $data);
-
-        return $data;
+        return $this->cache[$filename]['traitsIn'];
     }
 
     public function functionsIn(string $filename): array
     {
-        if ($this->has($filename, __METHOD__)) {
-            return $this->read($filename, __METHOD__);
+        if (!isset($this->cache[$filename])) {
+            $this->process($filename);
         }
 
-        $data = $this->coveredFileAnalyser->functionsIn($filename);
-
-        $this->write($filename, __METHOD__, $data);
-
-        return $data;
+        return $this->cache[$filename]['functionsIn'];
     }
 
     public function linesOfCodeFor(string $filename): LinesOfCode
     {
-        if ($this->has($filename, __METHOD__)) {
-            return $this->read($filename, __METHOD__, [LinesOfCode::class]);
+        if (!isset($this->cache[$filename])) {
+            $this->process($filename);
         }
 
-        $data = $this->coveredFileAnalyser->linesOfCodeFor($filename);
-
-        $this->write($filename, __METHOD__, $data);
-
-        return $data;
+        return $this->cache[$filename]['linesOfCodeFor'];
     }
 
     public function ignoredLinesFor(string $filename): array
     {
-        if (isset($this->inMemoryCacheForIgnoredLines[$filename])) {
-            return $this->inMemoryCacheForIgnoredLines[$filename];
+        if (!isset($this->cache[$filename])) {
+            $this->process($filename);
         }
 
-        if ($this->has($filename, __METHOD__)) {
-            return $this->read($filename, __METHOD__);
-        }
+        return $this->cache[$filename]['ignoredLinesFor'];
+    }
 
-        $this->inMemoryCacheForIgnoredLines[$filename] = $this->coveredFileAnalyser->ignoredLinesFor($filename);
+    public function process(string $filename): void
+    {
+        if ($this->has($filename, __CLASS__)) {
+            $this->cache[$filename] = $this->read($filename, __CLASS__, [LinesOfCode::class]);
+
+            return;
+        }
 
-        $this->write($filename, __METHOD__, $this->inMemoryCacheForIgnoredLines[$filename]);
+        $this->cache[$filename] = [
+            'classesIn'       => $this->coveredFileAnalyser->classesIn($filename),
+            'traitsIn'        => $this->coveredFileAnalyser->traitsIn($filename),
+            'functionsIn'     => $this->coveredFileAnalyser->functionsIn($filename),
+            'linesOfCodeFor'  => $this->coveredFileAnalyser->linesOfCodeFor($filename),
+            'ignoredLinesFor' => $this->coveredFileAnalyser->ignoredLinesFor($filename),
+        ];
 
-        return $this->inMemoryCacheForIgnoredLines[$filename];
+        $this->write($filename, __CLASS__, $this->cache[$filename]);
     }
 }