Merge branch 'dev'

Author: alancolant

README.md

@@ -43,13 +43,12 @@ class GetString extends \QuixLabs\LaravelHookSystem\Hook
 In the `register` method of your ServiceProvider:
 
 ```php
-use QuixLabs\LaravelHookSystem\Facades\HookManager;
 use Workbench\App\Hooks\GetString;
 
 class YourProvider{
     public function register()
     {
-        HookManager::registerHook(GetString::class);
+        \QuixLabs\LaravelHookSystem\HookRegistry::registerHook(GetString::class);
     }
 }
 
@@ -65,7 +64,7 @@ class YourController
     public function index()
     {
         $string = "";
-         \Workbench\App\Hooks\GetString::send($string);
+        \Workbench\App\Hooks\GetString::send($string);
         return $string;
     }
 }
@@ -111,12 +110,10 @@ class AppendRandomString
 In the `boot` method of your ServiceProvider:
 
 ```php
-use QuixLabs\LaravelHookSystem\Facades\HookManager;
-
 class YourProvider{
     public function boot()
     {
-        HookManager::registerInterceptor(\App\Interceptors\AppendRandomString::class);
+        \QuixLabs\LaravelHookSystem\HookRegistry::registerInterceptor(\App\Interceptors\AppendRandomString::class);
     }
 }
 ```

src/Facades/HookManager.php

@@ -11,7 +11,7 @@
  * @method static array<Hook|string> getHooks()
  * @method static array<int,callable[]> getInterceptorsForHook(Hook|string $hook)
  * @method static string getCacheFilepath()
- * @method static void loadCache()
+ * @method static void reloadCache()
  * @method static void createCache()
  * @method static void clearCache()
  * @method static bool isCached()

src/HookManager.php

@@ -13,11 +13,17 @@ class HookManager
      */
     protected array $hooks = [];
 
+    /**
+     * @var true
+     */
+    private bool $cached = false;
+
+    /**
+     * @throws \Exception
+     */
     public function __construct()
     {
-        if ($this->isCached()) {
-            $this->loadCache();
-        }
+        $this->reloadCache();
     }
 
     public function registerHook(Hook|string $hook): void
@@ -92,12 +98,20 @@ public function getCacheFilepath(): string
         return base_path('bootstrap/cache/hooks.php');
     }
 
-    public function loadCache(): void
+    public function reloadCache(): void
     {
+        if (! File::exists($this->getCacheFilepath())) {
+            $this->cached = false;
+
+            return;
+        }
+
         try {
             $this->hooks = require $this->getCacheFilepath();
+            $this->cached = true;
         } catch (\Throwable $e) {
-            throw new \RuntimeException('Unable to load hooks cache: '.$e->getMessage());
+            $this->clearCache();
+            $this->cached = false;
         }
     }
 
@@ -112,10 +126,11 @@ public function clearCache(): void
         if (File::exists($this->getCacheFilepath())) {
             File::delete($this->getCacheFilepath());
         }
+        $this->cached = false;
     }
 
     public function isCached(): bool
     {
-        return File::exists($this->getCacheFilepath());
+        return $this->cached;
     }
 }

src/HookRegistry.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace QuixLabs\LaravelHookSystem;
+
+use QuixLabs\LaravelHookSystem\Facades\HookManager;
+
+class HookRegistry
+{
+    protected static array $hooks = [];
+
+    protected static array $interceptors = [];
+
+    public static function registerHook($hook): void
+    {
+        if (static::booted() === true && ! HookManager::isCached()) {
+            Hookmanager::registerHook($hook);
+
+            return;
+        }
+        static::$hooks[] = $hook;
+    }
+
+    public static function registerInterceptor($interceptor): void
+    {
+        if (static::booted() === true && ! HookManager::isCached()) {
+            Hookmanager::registerInterceptor($interceptor);
+
+            return;
+        }
+        static::$interceptors[] = $interceptor;
+    }
+
+    public static function getHooks(): array
+    {
+        return static::$hooks;
+    }
+
+    public static function getInterceptors(): array
+    {
+        return static::$interceptors;
+    }
+
+    public static function clear(): void
+    {
+        static::$hooks = [];
+        static::$interceptors = [];
+    }
+
+    public static function booted(): bool
+    {
+        return app()->resolved('hooks_manager');
+    }
+}

src/Providers/ServiceProvider.php

@@ -2,41 +2,35 @@
 
 namespace QuixLabs\LaravelHookSystem\Providers;
 
-use Illuminate\Foundation\Application;
 use Illuminate\Foundation\Console\AboutCommand;
 use QuixLabs\LaravelHookSystem\Console\Commands\HooksCacheCommand;
 use QuixLabs\LaravelHookSystem\Console\Commands\HooksClearCommand;
 use QuixLabs\LaravelHookSystem\Console\Commands\HooksStatusCommand;
 use QuixLabs\LaravelHookSystem\Facades\HookManager as HookManagerFacade;
 use QuixLabs\LaravelHookSystem\HookManager;
+use QuixLabs\LaravelHookSystem\HookRegistry;
 use QuixLabs\LaravelHookSystem\Hooks\GetHooksTable;
 
 class ServiceProvider extends \Illuminate\Support\ServiceProvider
 {
     public function register(): void
     {
-        $this->_registerHookManager();
+        $this->app->singleton('hooks_manager', function () {
+            return new HookManager();
+        });
         $this->_registerCommands();
         $this->_registerHooks();
     }
 
     public function boot(): void
     {
+        $this->_bootHooksRegistry();
         $this->_appendInformationToAboutCommand();
     }
 
-    private function _registerHookManager(): void
-    {
-        $this->app->singleton('hooks_manager', function (Application $app) {
-            return new HookManager();
-        });
-    }
-
     private function _registerHooks(): void
     {
-        if (! HookManagerFacade::isCached()) {
-            HookManagerFacade::registerHook(GetHooksTable::class);
-        }
+        HookRegistry::registerHook(GetHooksTable::class);
     }
 
     private function _registerCommands(): void
@@ -57,8 +51,21 @@ private function _appendInformationToAboutCommand(): void
         }
         AboutCommand::add('Cache', fn () => [
             'Hooks' => HookManagerFacade::isCached()
-                    ? '<fg=green;options=bold>CACHED</>'
-                    : '<fg=yellow;options=bold>NOT CACHED</>',
+                ? '<fg=green;options=bold>CACHED</>'
+                : '<fg=yellow;options=bold>NOT CACHED</>',
         ]);
     }
+
+    private function _bootHooksRegistry(): void
+    {
+        if (! HookManagerFacade::isCached()) {
+            foreach (HookRegistry::getHooks() as $hook) {
+                HookManagerFacade::registerHook($hook);
+            }
+            foreach (HookRegistry::getInterceptors() as $interceptor) {
+                HookManagerFacade::registerInterceptor($interceptor);
+            }
+        }
+        HookRegistry::clear();
+    }
 }

tests/ArchTest.php renamed to tests/Ordered/ArchTest.php

@@ -1,48 +1,47 @@
 <?php
 
 use QuixLabs\LaravelHookSystem\Facades\HookManager;
+use QuixLabs\LaravelHookSystem\HookRegistry;
 use Workbench\App\Hooks\GetString;
 use Workbench\App\Interceptors\AppendRandomString;
 
-afterEach(function () {
-    HookManager::clearCache();
-    $this->app->forgetInstance('hooks_manager');
-    HookManager::clearResolvedInstances();
-});
-
 test('Can generate cache using facade', function () {
     HookManager::createCache();
+    HookManager::reloadCache();
     expect(HookManager::isCached())->toBeTrue();
 });
 
 test('Can clear cache using facade', function () {
     HookManager::createCache();
+    HookManager::reloadCache();
     expect(HookManager::isCached())->toBeTrue();
     HookManager::clearCache();
+    HookManager::reloadCache();
+
     expect(HookManager::isCached())->toBeFalse();
 });
 
 test('Remove hook when has no interceptors', function () {
-    HookManager::registerHook(GetString::class);
+    HookRegistry::registerHook(GetString::class);
     HookManager::createCache();
-    HookManager::loadCache();
+    HookManager::reloadCache();
     expect(HookManager::getHooks())->not->toContain(GetString::class);
 });
 
 test('Can cache single interceptor', function () {
-    HookManager::registerHook(GetString::class);
-    HookManager::registerInterceptor(AppendRandomString::class);
+    HookRegistry::registerHook(GetString::class);
+    HookRegistry::registerInterceptor(AppendRandomString::class);
     HookManager::createCache();
-    HookManager::loadCache();
+    HookManager::reloadCache();
     expect(HookManager::getInterceptorsForHook(GetString::class))->toHaveCount(1);
 });
 
 test('Can cache same interceptor twice', function () {
-    HookManager::registerHook(GetString::class);
-    HookManager::registerInterceptor(AppendRandomString::class);
-    HookManager::registerInterceptor(AppendRandomString::class);
+    HookRegistry::registerHook(GetString::class);
+    HookRegistry::registerInterceptor(AppendRandomString::class);
+    HookRegistry::registerInterceptor(AppendRandomString::class);
     HookManager::createCache();
-    HookManager::loadCache();
+    HookManager::reloadCache();
     expect(collect(HookManager::getInterceptorsForHook(GetString::class))->flatten(1))->toHaveCount(2);
 });
 
@@ -53,7 +52,8 @@
     expect(HookManager::isCached())->toBeTrue();
 });
 
-test('Throw error when cache file cannot be loaded', function () {
+test('Corrupted cache file will be removed', function () {
     file_put_contents(HookManager::getCacheFilepath(), '<?php return teer;');
-    HookManager::loadCache();
-})->throws('Unable to load hooks cache');
+    HookManager::reloadCache();
+    expect(HookManager::isCached())->toBeFalse();
+});

tests/CacheTest.php renamed to tests/Ordered/CacheTest.php

@@ -6,26 +6,24 @@
 use QuixLabs\LaravelHookSystem\Console\Commands\HooksClearCommand;
 use QuixLabs\LaravelHookSystem\Console\Commands\HooksStatusCommand;
 use QuixLabs\LaravelHookSystem\Facades\HookManager;
+use QuixLabs\LaravelHookSystem\HookRegistry;
 use Workbench\App\Hooks\GetArray;
 use Workbench\App\Hooks\GetString;
 use Workbench\App\Interceptors\AppendPriority2;
 use Workbench\App\Interceptors\AppendPriority4;
 
-afterEach(function () {
-    HookManager::clearCache();
-    $this->app->forgetInstance('hooks_manager');
-    HookManager::clearResolvedInstances();
-});
-
 test('Can call hooks:cache', function () {
     $this->artisan(HooksCacheCommand::class)->assertSuccessful();
+    HookManager::reloadCache();
     expect(HookManager::isCached())->toBeTrue();
 });
 
 test('Can call hooks:clear', function () {
     HookManager::createCache();
+    HookManager::reloadCache();
     expect(HookManager::isCached())->toBeTrue();
     $this->artisan(HooksClearCommand::class)->assertSuccessful();
+    HookManager::reloadCache();
     expect(HookManager::isCached())->toBeFalse();
 });
 
@@ -35,6 +33,7 @@
 
 test('hooks:status show warning when cached', function () {
     HookManager::createCache();
+    HookManager::reloadCache();
     expect(HookManager::isCached())->toBeTrue();
     $this->artisan(HooksStatusCommand::class)->assertSuccessful()->expectsOutputToContain('Hooks are actually cached!');
 });
@@ -44,18 +43,18 @@
 });
 
 test('hooks:status show all hooks', function () {
-    HookManager::registerHook(GetString::class);
-    HookManager::registerHook(GetArray::class);
+    HookRegistry::registerHook(GetString::class);
+    HookRegistry::registerHook(GetArray::class);
 
     // Keep below multiple call, not work due to termwind multiline if expects are chained
     $this->artisan(HooksStatusCommand::class)->assertSuccessful()->expectsOutputToContain(GetArray::class);
     $this->artisan(HooksStatusCommand::class)->assertSuccessful()->expectsOutputToContain(GetString::class);
 });
 
 test('hooks:status show all interceptors', function () {
-    HookManager::registerHook(GetString::class);
-    HookManager::registerInterceptor(AppendPriority2::class);
-    HookManager::registerInterceptor(AppendPriority4::class);
+    HookRegistry::registerHook(GetString::class);
+    HookRegistry::registerInterceptor(AppendPriority2::class);
+    HookRegistry::registerInterceptor(AppendPriority4::class);
 
     // Keep below multiple call, not work due to termwind multiline if expects are chained
     $this->artisan(HooksStatusCommand::class)->assertSuccessful()->expectsOutputToContain(AppendPriority2::class);
@@ -77,7 +76,7 @@
 
 test('Display hooks cached information when cached in about config', function () {
     HookManager::createCache();
-    HookManager::loadCache();
+    HookManager::reloadCache();
     Artisan::call(AboutCommand::class);
     $output = Artisan::output();
     expect(preg_match("/Hooks\s[.]+\sCACHED/", $output))->toBe(1);