Merge pull request #44 from DarkGhostHunter/master

Added ignoring unreadable files

.gitattributes

@@ -9,3 +9,4 @@
 /.scrutinizer.yml   export-ignore
 /tests              export-ignore
 /.editorconfig      export-ignore
+/.github            export-ignore

README.md

@@ -31,6 +31,7 @@ This package generates a [PHP 7.4 preloading](https://www.php.net/manual/en/opca
   * [Generation](#generation)
     + [`memoryLimit()`](#memorylimit)
     + [`useRequire()`](#userequire)
+    + [`ignoreNotFound()`](#ignorenotfound)
   * [Compilation](#compilation)
     + [`writeTo()`](#writeto)
     + [`getList()`](#getlist)
@@ -244,6 +245,22 @@ Preloader::make()->useRequire(__DIR__ . '/../vendor/autoload.php');
 
 > You may get some warnings when compiling a file with unresolved links. These are not critical, since these files usually are the least requested in your application.
 
+#### `ignoreNotFound()`
+
+Some applications may create files at runtime that are genuinely cached by Opcache, but doesn't exist when the application is firstly deployed.
+
+To avoid this problem, you can use the `ignoreNotFound()`, which will compile a script that ignore files not found or are unreadable.
+
+```php
+<?php
+
+use DarkGhostHunter\Preloader\Preloader;
+
+Preloader::make()->ignoreNotFound();
+```
+
+> If the file is readable but its preloading returns an error, it will throw an exception nonetheless.
+
 ### Compilation
 
 #### `writeTo()`

src/GeneratesScript.php

@@ -25,6 +25,13 @@ trait GeneratesScript
      */
     protected ?string $autoloader = null;
 
+    /**
+     * If the script should ignore files not found.
+     *
+     * @var bool
+     */
+    protected bool $ignoreNotFound = false;
+
     /**
      * Memory limit (in MB) to constrain the file list.
      *
@@ -54,6 +61,19 @@ public function useRequire(string $autoloader) : self
         return $this;
     }
 
+    /**
+     * If it should NOT throw an exception when a file to preload doesn't exists.
+     *
+     * @param  bool  $ignore
+     * @return $this
+     */
+    public function ignoreNotFound($ignore = true)
+    {
+        $this->ignoreNotFound = $ignore;
+
+        return $this;
+    }
+
     /**
      * Returns a digestible Opcache configuration
      *

src/Preloader.php

@@ -173,6 +173,7 @@ protected function prepareCompiler(string $path)
         $this->compiler->opcacheConfig = $this->getOpcacheConfig();
         $this->compiler->preloaderConfig = $this->getPreloaderConfig();
         $this->compiler->useRequire = $this->useRequire;
+        $this->compiler->ignoreNotFound = $this->ignoreNotFound;
         $this->compiler->autoloader = $this->autoloader;
         $this->compiler->writeTo = $path;
 

src/PreloaderCompiler.php

@@ -55,6 +55,13 @@ class PreloaderCompiler
      */
     public string $writeTo;
 
+    /**
+     * If it should add exception for not-found files.
+     *
+     * @var bool
+     */
+    public bool $ignoreNotFound;
+
     /**
      * Returns a compiled string
      *
@@ -68,6 +75,7 @@ public function compile() : string
             '@autoload'     => isset($this->autoloader)
                 ? 'require_once \'' . realpath($this->autoloader) . '\';': null,
             '@list'         => $this->parseList(),
+            '@failure'      => $this->ignoreNotFound ? 'continue;' : 'throw new \Exception("{$file} does not exist or is unreadable.");',
             '@mechanism'    => $this->useRequire
                 ? 'require_once $file' : 'opcache_compile_file($file)',
         ]);

src/preload.php.stub

@@ -41,7 +41,7 @@ $files = [@list];
 foreach ($files as $file) {
     try {
         if (!(is_file($file) && is_readable($file))) {
-            throw new \Exception("{$file} does not exist or is unreadable.");
+            @failure
         }
         @mechanism;
     } catch (\Throwable $e) {

tests/PreloaderTest.php

@@ -403,6 +403,38 @@ public function test_excludes_phantom_preload_variable()
         $this->assertStringNotContainsString('$PRELOAD$', $contents);
     }
 
+    public function test_includes_error_when_files_dont_exists()
+    {
+        $this->mockOpcache();
+
+        $preloader = new Preloader(new PreloaderCompiler, new PreloaderLister, $this->opcache);
+
+        $preloader->writeTo($this->preloaderPath);
+
+        $contents = file_get_contents($this->preloaderPath);
+
+        $this->assertStringContainsString('throw new \Exception("{$file} does not exist or is unreadable.");', $contents);
+        $this->assertStringNotContainsString('if (!(is_file($file) && is_readable($file))) {
+            continue;
+        }', $contents);
+    }
+
+    public function test_excludes_exception_if_file_doesnt_exists_by_default()
+    {
+        $this->mockOpcache();
+
+        $preloader = new Preloader(new PreloaderCompiler, new PreloaderLister, $this->opcache);
+
+        $preloader->ignoreNotFound()->writeTo($this->preloaderPath);
+
+        $contents = file_get_contents($this->preloaderPath);
+
+        $this->assertStringNotContainsString('throw new \Exception("{$file} does not exist or is unreadable.");', $contents);
+        $this->assertStringContainsString('if (!(is_file($file) && is_readable($file))) {
+            continue;
+        }', $contents);
+    }
+
     public function test_exception_when_autoload_doesnt_exists()
     {
         $this->expectException(LogicException::class);