Re-adding caching of Metas & fixing how files are scanned and ref dependencies

lib/Builder.php

@@ -15,7 +15,12 @@
 use Doctrine\RST\Event\PreBuildScanEvent;
 use Doctrine\RST\Meta\Metas;
 use Symfony\Component\Filesystem\Filesystem;
+use function file_exists;
+use function file_get_contents;
+use function file_put_contents;
 use function is_dir;
+use function serialize;
+use function unserialize;
 
 class Builder
 {
@@ -37,12 +42,6 @@ class Builder
     /** @var Documents */
     private $documents;
 
-    /** @var ParseQueue */
-    private $parseQueue;
-
-    /** @var Scanner */
-    private $scanner;
-
     /** @var Copier */
     private $copier;
 
@@ -66,10 +65,6 @@ public function __construct(?Kernel $kernel = null)
             $this->metas
         );
 
-        $this->parseQueue = new Builder\ParseQueue($this->documents);
-
-        $this->scanner = new Builder\Scanner($this->parseQueue, $this->metas);
-
         $this->copier = new Builder\Copier($this->filesystem);
 
         $this->kernel->initBuilder($this);
@@ -95,11 +90,6 @@ public function getDocuments() : Documents
         return $this->documents;
     }
 
-    public function getParseQueue() : Builder\ParseQueue
-    {
-        return $this->parseQueue;
-    }
-
     public function getErrorManager() : ErrorManager
     {
         return $this->errorManager;
@@ -126,11 +116,17 @@ public function build(
             $this->filesystem->mkdir($targetDirectory, 0755);
         }
 
-        $this->scan($directory, $targetDirectory);
+        if ($this->configuration->getUseCachedMetas()) {
+            $this->loadCachedMetas($targetDirectory);
+        }
+
+        $parseQueue = $this->scan($directory, $targetDirectory);
 
-        $this->parse($directory, $targetDirectory);
+        $this->parse($directory, $targetDirectory, $parseQueue);
 
         $this->render($directory, $targetDirectory);
+
+        $this->saveMetas($targetDirectory);
     }
 
     public function copy(string $source, ?string $destination = null) : self
@@ -147,19 +143,23 @@ public function mkdir(string $directory) : self
         return $this;
     }
 
-    private function scan(string $directory, string $targetDirectory) : void
+    private function scan(string $directory, string $targetDirectory) : ParseQueue
     {
         $this->configuration->dispatchEvent(
             PreBuildScanEvent::PRE_BUILD_SCAN,
             new PreBuildScanEvent($this, $directory, $targetDirectory)
         );
 
-        $this->scanner->scan($directory, $this->getIndexName());
+        $scanner = new Scanner(
+            $this->configuration->getSourceFileExtension(),
+            $directory,
+            $this->metas
+        );
 
-        $this->scanner->scanMetas($directory);
+        return $scanner->scan();
     }
 
-    private function parse(string $directory, string $targetDirectory) : void
+    private function parse(string $directory, string $targetDirectory, ParseQueue $parseQueue) : void
     {
         $this->configuration->dispatchEvent(
             PreBuildParseEvent::PRE_BUILD_PARSE,
@@ -169,16 +169,14 @@ private function parse(string $directory, string $targetDirectory) : void
         $parseQueueProcessor = new ParseQueueProcessor(
             $this->kernel,
             $this->errorManager,
-            $this->parseQueue,
             $this->metas,
             $this->documents,
-            $this->scanner,
             $directory,
             $targetDirectory,
             $this->configuration->getFileExtension()
         );
 
-        $parseQueueProcessor->process();
+        $parseQueueProcessor->process($parseQueue);
     }
 
     private function render(string $directory, string $targetDirectory) : void
@@ -198,4 +196,30 @@ private function render(string $directory, string $targetDirectory) : void
             new PostBuildRenderEvent($this, $directory, $targetDirectory)
         );
     }
+
+    private function loadCachedMetas(string $targetDirectory) : void
+    {
+        $metaCachePath = $this->getMetaCachePath($targetDirectory);
+        if (! file_exists($metaCachePath)) {
+            return;
+        }
+
+        $contents = file_get_contents($metaCachePath);
+
+        if ($contents === false) {
+            return;
+        }
+
+        $this->metas->setMetaEntries(unserialize($contents));
+    }
+
+    private function saveMetas(string $targetDirectory) : void
+    {
+        file_put_contents($this->getMetaCachePath($targetDirectory), serialize($this->metas->getAll()));
+    }
+
+    private function getMetaCachePath(string $targetDirectory) : string
+    {
+        return $targetDirectory . '/metas.php';
+    }
 }

lib/Builder/ParseQueue.php

@@ -4,51 +4,52 @@
 
 namespace Doctrine\RST\Builder;
 
-use function array_shift;
+use InvalidArgumentException;
+use function array_filter;
+use function array_key_exists;
+use function array_keys;
+use function sprintf;
 
-class ParseQueue
+final class ParseQueue
 {
-    /** @var Documents */
-    private $documents;
-
-    /** @var string[] */
-    private $parseQueue = [];
-
-    /** @var int[] */
-    private $states = [];
-
-    public function __construct(Documents $documents)
+    /**
+     * An array where each key is the filename and the value is a
+     * boolean indicating if the file needs to be parsed or not.
+     *
+     * @var bool[]
+     */
+    private $fileStatuses = [];
+
+    public function addFile(string $filename, bool $parseNeeded) : void
     {
-        $this->documents = $documents;
-    }
+        if (isset($this->fileStatuses[$filename])) {
+            throw new InvalidArgumentException(sprintf('File "%s" is already in the parse queue', $filename));
+        }
 
-    public function getState(string $file) : ?int
-    {
-        return $this->states[$file] ?? null;
+        $this->fileStatuses[$filename] = $parseNeeded;
     }
 
-    public function setState(string $file, int $state) : void
+    public function isFileKnownToParseQueue(string $filename) : bool
     {
-        $this->states[$file] = $state;
+        return array_key_exists($filename, $this->fileStatuses);
     }
 
-    public function getFileToParse() : ?string
+    public function doesFileRequireParsing(string $filename) : bool
     {
-        if ($this->parseQueue !== []) {
-            return array_shift($this->parseQueue);
+        if (! $this->isFileKnownToParseQueue($filename)) {
+            throw new InvalidArgumentException(sprintf('File "%s" is not known to the parse queue', $filename));
         }
 
-        return null;
+        return $this->fileStatuses[$filename];
     }
 
-    public function addToParseQueue(string $file) : void
+    /**
+     * @return string[]
+     */
+    public function getAllFilesThatRequireParsing() : array
     {
-        $this->states[$file] = State::PARSE;
-
-        if ($this->documents->hasDocument($file)) {
-            return;
-        }
-
-        $this->parseQueue[$file] = $file;
+        return array_keys(array_filter($this->fileStatuses, static function (bool $parseNeeded) {
+            return $parseNeeded;
+        }));
     }
 }

lib/Builder/ParseQueueProcessor.php

@@ -9,8 +9,6 @@
 use Doctrine\RST\Meta\Metas;
 use Doctrine\RST\Nodes\DocumentNode;
 use Doctrine\RST\Parser;
-use function array_filter;
-use function file_exists;
 use function filectime;
 
 class ParseQueueProcessor
@@ -21,18 +19,12 @@ class ParseQueueProcessor
     /** @var ErrorManager */
     private $errorManager;
 
-    /** @var ParseQueue */
-    private $parseQueue;
-
     /** @var Metas */
     private $metas;
 
     /** @var Documents */
     private $documents;
 
-    /** @var Scanner */
-    private $scanner;
-
     /** @var string */
     private $directory;
 
@@ -45,28 +37,24 @@ class ParseQueueProcessor
     public function __construct(
         Kernel $kernel,
         ErrorManager $errorManager,
-        ParseQueue $parseQueue,
         Metas $metas,
         Documents $documents,
-        Scanner $scanner,
         string $directory,
         string $targetDirectory,
         string $fileExtension
     ) {
         $this->kernel          = $kernel;
         $this->errorManager    = $errorManager;
-        $this->parseQueue      = $parseQueue;
         $this->metas           = $metas;
         $this->documents       = $documents;
-        $this->scanner         = $scanner;
         $this->directory       = $directory;
         $this->targetDirectory = $targetDirectory;
         $this->fileExtension   = $fileExtension;
     }
 
-    public function process() : void
+    public function process(ParseQueue $parseQueue) : void
     {
-        while ($file = $this->parseQueue->getFileToParse()) {
+        foreach ($parseQueue->getAllFilesThatRequireParsing() as $file) {
             $this->processFile($file);
         }
     }
@@ -85,20 +73,14 @@ private function processFile(string $file) : void
 
         $this->kernel->postParse($document);
 
-        $dependencies = $environment->getDependencies();
-
-        foreach ($this->buildDependenciesToScan($dependencies) as $dependency) {
-            $this->scanner->scan($this->directory, $dependency);
-        }
-
         $this->metas->set(
             $file,
             $this->buildDocumentUrl($document),
             (string) $document->getTitle(),
             $document->getTitles(),
             $document->getTocs(),
             (int) filectime($fileAbsolutePath),
-            $dependencies,
+            $environment->getDependencies(),
             $environment->getLinks()
         );
     }
@@ -117,18 +99,6 @@ private function createFileParser(string $file) : Parser
         return $parser;
     }
 
-    /**
-     * @param string[] $dependencies
-     *
-     * @return string[]
-     */
-    private function buildDependenciesToScan(array $dependencies) : array
-    {
-        return array_filter($dependencies, function (string $dependency) : bool {
-            return file_exists($this->buildFileAbsolutePath($dependency));
-        });
-    }
-
     private function buildFileAbsolutePath(string $file) : string
     {
         return $this->directory . '/' . $file . '.rst';