Add parse cache

.gitignore

@@ -12,4 +12,5 @@ composer.lock
 .php-version
 composer.phar
 .phpunit.cache/
-.vscode
+.vscode
+.phparkitect.cache

src/Analyzer/CachedFileParser.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Arkitect\Analyzer;
+
+class CachedFileParser implements Parser
+{
+    /** @var array<string, array{hash: string, result: ParserResult}> */
+    private array $entries = [];
+
+    private bool $dirty = false;
+
+    private string $filePath;
+
+    private Parser $innerParser;
+
+    public function __construct(Parser $innerParser, string $cacheFilePath)
+    {
+        $this->filePath = $cacheFilePath;
+        $this->innerParser = $innerParser;
+
+        if (file_exists($cacheFilePath)) {
+            $data = unserialize((string) file_get_contents($cacheFilePath));
+            if (\is_array($data)) {
+                $this->entries = $data;
+            }
+        }
+    }
+
+    public function __destruct()
+    {
+        if ($this->dirty) {
+            file_put_contents($this->filePath, serialize($this->entries));
+        }
+    }
+
+    public function parse(string $fileContent, string $filename): ParserResult
+    {
+        $cachedResult = $this->get($filename, md5($fileContent));
+
+        if (null !== $cachedResult) {
+            return $cachedResult;
+        }
+
+        $result = $this->innerParser->parse($fileContent, $filename);
+
+        $this->set($filename, md5($fileContent), $result);
+
+        return $result;
+    }
+
+    public function get(string $filename, string $contentHash): ?ParserResult
+    {
+        if (!isset($this->entries[$filename])) {
+            return null;
+        }
+
+        if ($this->entries[$filename]['hash'] !== $contentHash) {
+            return null;
+        }
+
+        return $this->entries[$filename]['result'];
+    }
+
+    public function set(string $filename, string $contentHash, ParserResult $result): void
+    {
+        $this->entries[$filename] = ['hash' => $contentHash, 'result' => $result];
+        $this->dirty = true;
+    }
+}

src/Analyzer/FileParserFactory.php

@@ -10,19 +10,32 @@
 
 class FileParserFactory
 {
-    public static function createFileParser(TargetPhpVersion $targetPhpVersion, bool $parseCustomAnnotations = true): FileParser
-    {
-        return new FileParser(
+    public static function createFileParser(
+        TargetPhpVersion $targetPhpVersion,
+        bool $parseCustomAnnotations = true,
+        ?string $cacheFilePath = null,
+    ): Parser {
+        $fp = new FileParser(
             new NodeTraverser(),
             new FileVisitor(new ClassDescriptionBuilder()),
             new NameResolver(),
             new DocblockTypesResolver($parseCustomAnnotations),
             $targetPhpVersion
         );
+
+        if (null !== $cacheFilePath) {
+            $fp = new CachedFileParser($fp, $cacheFilePath);
+        }
+
+        return $fp;
     }
 
-    public static function forPhpVersion(string $targetPhpVersion): FileParser
+    public static function forPhpVersion(string $targetPhpVersion): Parser
     {
-        return self::createFileParser(TargetPhpVersion::create($targetPhpVersion), true);
+        return self::createFileParser(
+            TargetPhpVersion::create($targetPhpVersion),
+            true,
+            null
+        );
     }
 }

src/Analyzer/FilesToParse.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Arkitect\Analyzer;
+
+use Symfony\Component\Finder\SplFileInfo;
+
+/**
+ * @template-implements \IteratorAggregate<SplFileInfo>
+ */
+class FilesToParse implements \IteratorAggregate
+{
+    /** @var array<SplFileInfo> */
+    private array $files = [];
+
+    public function add(SplFileInfo $file): void
+    {
+        $this->files[] = $file;
+    }
+
+    public function getIterator(): \Traversable
+    {
+        return new \ArrayIterator($this->files);
+    }
+}

src/Analyzer/ParsedFiles.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Arkitect\Analyzer;
+
+class ParsedFiles
+{
+    private array $data = [];
+
+    public function add(string $relativeFilePath, ParserResult $result): void
+    {
+        $this->data[$relativeFilePath] = $result;
+    }
+
+    public function get(string $relativeFilePath): ?ParserResult
+    {
+        return $this->data[$relativeFilePath] ?? null;
+    }
+}

src/CLI/Command/Check.php

@@ -30,6 +30,7 @@ class Check extends Command
     private const IGNORE_BASELINE_LINENUMBERS_PARAM = 'ignore-baseline-linenumbers';
     private const FORMAT_PARAM = 'format';
     private const AUTOLOAD_PARAM = 'autoload';
+    private const NO_CACHE_PARAM = 'no-cache';
 
     private const GENERATE_BASELINE_PARAM = 'generate-baseline';
     private const DEFAULT_RULES_FILENAME = 'phparkitect.php';
@@ -105,6 +106,12 @@ protected function configure(): void
                 'a',
                 InputOption::VALUE_REQUIRED,
                 'Specify an autoload file to use',
+            )
+            ->addOption(
+                self::NO_CACHE_PARAM,
+                'o',
+                InputOption::VALUE_NONE,
+                'Disable cache'
             );
     }
 
@@ -124,6 +131,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
             $generateBaseline = $input->getOption(self::GENERATE_BASELINE_PARAM);
             $phpVersion = $input->getOption('target-php-version');
             $format = $input->getOption(self::FORMAT_PARAM);
+            $noCache = (bool) $input->getOption(self::NO_CACHE_PARAM);
 
             // we write everything on STDERR apart from the list of violations which goes on STDOUT
             // this allows to pipe the output of this command to a file while showing output on the terminal
@@ -139,7 +147,8 @@ protected function execute(InputInterface $input, OutputInterface $output): int
                 ->baselineFilePath(Baseline::resolveFilePath($useBaseline, self::DEFAULT_BASELINE_FILENAME))
                 ->ignoreBaselineLinenumbers($ignoreBaselineLinenumbers)
                 ->skipBaseline($skipBaseline)
-                ->format($format);
+                ->format($format)
+                ->noCache($noCache);
 
             $this->requireAutoload($output, $config->getAutoloadFilePath());
             $printer = $this->createPrinter($output, $config->getFormat());

src/CLI/Command/DebugExpression.php

@@ -92,11 +92,11 @@ protected function execute(InputInterface $input, OutputInterface $output): int
     /**
      * @throws \Arkitect\Exceptions\PhpVersionNotValidException
      */
-    private function getParser(InputInterface $input): \Arkitect\Analyzer\FileParser
+    private function getParser(InputInterface $input): \Arkitect\Analyzer\Parser
     {
         $phpVersion = $input->getOption('target-php-version');
         $targetPhpVersion = TargetPhpVersion::create($phpVersion);
-        $fileParser = FileParserFactory::createFileParser($targetPhpVersion);
+        $fileParser = FileParserFactory::createFileParser($targetPhpVersion, true, null);
 
         return $fileParser;
     }

src/CLI/Config.php

@@ -31,6 +31,8 @@ class Config
 
     private TargetPhpVersion $targetPhpVersion;
 
+    private ?string $cacheFilePath = null;
+
     public function __construct()
     {
         $this->classSetRules = [];
@@ -43,6 +45,7 @@ public function __construct()
         $this->format = PrinterFactory::default();
         $this->autoloadFilePath = null;
         $this->targetPhpVersion = TargetPhpVersion::latest();
+        $this->cacheFilePath = '.phparkitect.cache';
     }
 
     public function add(ClassSet $classSet, ArchRule ...$rules): self
@@ -167,4 +170,18 @@ public function getAutoloadFilePath(): ?string
     {
         return $this->autoloadFilePath;
     }
+
+    public function noCache(bool $noCache): self
+    {
+        if ($noCache) {
+            $this->cacheFilePath = null;
+        }
+
+        return $this;
+    }
+
+    public function getCacheFilePath(): ?string
+    {
+        return $this->cacheFilePath;
+    }
 }

src/CLI/Runner.php

@@ -6,6 +6,8 @@
 
 use Arkitect\Analyzer\ClassDescription;
 use Arkitect\Analyzer\FileParserFactory;
+use Arkitect\Analyzer\FilesToParse;
+use Arkitect\Analyzer\ParsedFiles;
 use Arkitect\Analyzer\Parser;
 use Arkitect\Analyzer\ParsingErrors;
 use Arkitect\ClassSetRules;
@@ -45,17 +47,46 @@ public function check(
         Violations $violations,
         ParsingErrors $parsingErrors,
         bool $stopOnFailure,
+    ): void {
+        // first step: collect all files to parse
+        $filesToParse = $this->collectFilesToParse($classSetRule);
+
+        // second step: parse all files and collect results
+        $parsedFiles = $this->collectParsedFiles(
+            $filesToParse,
+            $fileParser,
+            $progress
+        );
+
+        // third step: check all rules on all files
+        $this->checkRulesOnParsedFiles(
+            $classSetRule,
+            $parsedFiles,
+            $violations,
+            $parsingErrors,
+            $stopOnFailure
+        );
+    }
+
+    public function checkRulesOnParsedFiles(
+        ClassSetRules $classSetRule,
+        ParsedFiles $parsedFiles,
+        Violations $violations,
+        ParsingErrors $parsingErrors,
+        bool $stopOnFailure,
     ): void {
         /** @var SplFileInfo $file */
         foreach ($classSetRule->getClassSet() as $file) {
-            $fileViolations = new Violations();
-
-            $progress->startParsingFile($file->getRelativePathname());
+            $result = $parsedFiles->get($file->getRelativePathname());
 
-            $result = $fileParser->parse($file->getContents(), $file->getRelativePathname());
+            if (null === $result) {
+                continue; // this should not happen
+            }
 
             $parsingErrors->merge($result->parsingErrors());
 
+            $fileViolations = new Violations();
+
             /** @var ClassDescription $classDescription */
             foreach ($result->classDescriptions() as $classDescription) {
                 foreach ($classSetRule->getRules() as $rule) {
@@ -70,9 +101,37 @@ public function check(
             }
 
             $violations->merge($fileViolations);
+        }
+    }
+
+    protected function collectFilesToParse(ClassSetRules $classSetRule): FilesToParse
+    {
+        $filesToParse = new FilesToParse();
+
+        /** @var SplFileInfo $file */
+        foreach ($classSetRule->getClassSet() as $file) {
+            $filesToParse->add($file);
+        }
+
+        return $filesToParse;
+    }
+
+    protected function collectParsedFiles(FilesToParse $filesToParse, Parser $fileParser, Progress $progress): ParsedFiles
+    {
+        $parsedFiles = new ParsedFiles();
+
+        /** @var SplFileInfo $file */
+        foreach ($filesToParse as $file) {
+            $progress->startParsingFile($file->getRelativePathname());
+
+            $result = $fileParser->parse($file->getContents(), $file->getRelativePathname());
+
+            $parsedFiles->add($file->getRelativePathname(), $result);
 
             $progress->endParsingFile($file->getRelativePathname());
         }
+
+        return $parsedFiles;
     }
 
     protected function doRun(Config $config, Progress $progress): array
@@ -82,15 +141,23 @@ protected function doRun(Config $config, Progress $progress): array
 
         $fileParser = FileParserFactory::createFileParser(
             $config->getTargetPhpVersion(),
-            $config->isParseCustomAnnotationsEnabled()
+            $config->isParseCustomAnnotationsEnabled(),
+            $config->getCacheFilePath()
         );
 
         /** @var ClassSetRules $classSetRule */
         foreach ($config->getClassSetRules() as $classSetRule) {
             $progress->startFileSetAnalysis($classSetRule->getClassSet());
 
             try {
-                $this->check($classSetRule, $progress, $fileParser, $violations, $parsingErrors, $config->isStopOnFailure());
+                $this->check(
+                    $classSetRule,
+                    $progress,
+                    $fileParser,
+                    $violations,
+                    $parsingErrors,
+                    $config->isStopOnFailure()
+                );
             } catch (FailOnFirstViolationException $e) {
                 break;
             } finally {