Support Laravel Debugbar 4 (Laravel 13)

Plugin.php

@@ -2,17 +2,15 @@
 
 use Backend\Classes\Controller as BackendController;
 use Backend\Models\UserRole;
-use Barryvdh\Debugbar\Facades\Debugbar;
-use Barryvdh\Debugbar\LaravelDebugbar;
-use Barryvdh\Debugbar\SymfonyHttpDriver;
+use Fruitcake\LaravelDebugbar\Facades\Debugbar;
+use Fruitcake\LaravelDebugbar\LaravelDebugbar;
 use Cms\Classes\Controller as CmsController;
 use Cms\Classes\Layout;
 use Cms\Classes\Page;
 use Config;
 use Event;
 use Illuminate\Contracts\Http\Kernel as HttpKernelContract;
 use Illuminate\Foundation\AliasLoader;
-use Illuminate\Session\SessionManager;
 use System\Classes\CombineAssets;
 use System\Classes\PluginBase;
 use Twig\Extension\ProfilerExtension;
@@ -61,16 +59,12 @@ public function register()
         $this->app->register(\Winter\Debugbar\Classes\ServiceProvider::class);
 
         // Replace the LaravelDebugbar with the WinterDebugbar
+        // Laravel Debugbar 4 configures its own HTTP driver (LaravelHttpDriver), so we only
+        // need to swap in Winter's Debugbar subclass for the custom JavascriptRenderer styling.
+        // Resolve through the container so the constructor (Application $app, Request $request)
+        // dependencies are injected (Laravel Debugbar 4 requires both).
         $this->app->singleton(LaravelDebugbar::class, function ($app) {
-            $debugbar = new WinterDebugbar($app);
-
-            if ($app->bound(SessionManager::class)) {
-                $sessionManager = $app->make(SessionManager::class);
-                $httpDriver = new SymfonyHttpDriver($sessionManager);
-                $debugbar->setHttpDriver($httpDriver);
-            }
-
-            return $debugbar;
+            return $app->make(WinterDebugbar::class);
         });
 
         // Register alias
@@ -118,10 +112,12 @@ public function addGlobalCollectors()
             // Disable original models collector because it will be replaced
             Config::set('debugbar.collectors.models', false);
 
-            /** @var \Barryvdh\Debugbar\LaravelDebugbar $debugBar */
-            $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+            /** @var \Fruitcake\LaravelDebugbar\LaravelDebugbar $debugBar */
+            $debugBar = $this->app->make(\Fruitcake\LaravelDebugbar\LaravelDebugbar::class);
             $modelsCollector = $this->app->make(ModelsCollector::class);
-            $debugBar->addCollector($modelsCollector);
+            if (!$debugBar->hasCollector($modelsCollector->getName())) {
+                $debugBar->addCollector($modelsCollector);
+            }
         }
     }
 
@@ -130,8 +126,8 @@ public function addGlobalCollectors()
      */
     public function addFrontendCollectors()
     {
-        /** @var \Barryvdh\Debugbar\LaravelDebugbar $debugBar */
-        $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+        /** @var \Fruitcake\LaravelDebugbar\LaravelDebugbar $debugBar */
+        $debugBar = $this->app->make(\Fruitcake\LaravelDebugbar\LaravelDebugbar::class);
 
         if (Config::get('debugbar.collectors.cms', true)) {
             // Disable route collector as the CMS collector presents this info instead
@@ -164,8 +160,8 @@ public function addFrontendCollectors()
      */
     public function addBackendCollectors()
     {
-        /** @var \Barryvdh\Debugbar\LaravelDebugbar $debugBar */
-        $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+        /** @var \Fruitcake\LaravelDebugbar\LaravelDebugbar $debugBar */
+        $debugBar = $this->app->make(\Fruitcake\LaravelDebugbar\LaravelDebugbar::class);
 
         if (Config::get('debugbar.collectors.backend', true)) {
             Event::listen('backend.page.beforeDisplay', function (BackendController $controller, $action, array $params) use ($debugBar) {
@@ -183,7 +179,7 @@ public function addBackendCollectors()
     protected function registerCmsTwigExtensions()
     {
         $profile = new Profile;
-        $debugBar = $this->app->make(\Barryvdh\Debugbar\LaravelDebugbar::class);
+        $debugBar = $this->app->make(\Fruitcake\LaravelDebugbar\LaravelDebugbar::class);
 
         Event::listen('cms.page.beforeDisplay', function ($controller, $url, $page) use ($profile, $debugBar) {
             $twig = $controller->getTwig();
@@ -197,9 +193,11 @@ protected function registerCmsTwigExtensions()
             }
         });
 
+        // php-debugbar 2.x (shipped with Laravel Debugbar 4) no longer bundles a Twig profile
+        // collector, so only register one when the bridge class is actually available.
         if (class_exists(\DebugBar\Bridge\NamespacedTwigProfileCollector::class)) {
             $debugBar->addCollector(new \DebugBar\Bridge\NamespacedTwigProfileCollector($profile));
-        } else {
+        } elseif (class_exists(\DebugBar\Bridge\TwigProfileCollector::class)) {
             $debugBar->addCollector(new \DebugBar\Bridge\TwigProfileCollector($profile));
         }
     }

classes/ServiceProvider.php

@@ -1,6 +1,7 @@
 <?php namespace Winter\Debugbar\Classes;
 
-use Barryvdh\Debugbar\ServiceProvider as BaseServiceProvider;
+use Fruitcake\LaravelDebugbar\ServiceProvider as BaseServiceProvider;
+use Illuminate\Contracts\Events\Dispatcher;
 use Illuminate\Contracts\Http\Kernel;
 use Winter\Debugbar\Middleware\InjectDebugbar;
 
@@ -9,14 +10,31 @@
  */
 class ServiceProvider extends BaseServiceProvider
 {
+    /**
+     * Bootstrap the application events.
+     *
+     * Laravel Debugbar 4 no longer registers an injection middleware; instead the base
+     * service provider injects the Debugbar via a RequestHandled event listener. We still
+     * need Winter's InjectDebugbar middleware so that injection and request storage can be
+     * gated by the winter.debugbar permissions, so we push it onto the kernel here. The
+     * middleware short-circuits the base listener (by disabling the Debugbar) whenever the
+     * current user is not permitted to view it.
+     */
+    public function boot(Dispatcher $events): void
+    {
+        parent::boot($events);
+
+        $this->registerMiddleware(InjectDebugbar::class);
+    }
+
     /**
      * Register the Debugbar Middleware
      *
      * @param  string $middleware
      */
-    protected function registerMiddleware($middleware)
+    protected function registerMiddleware(string $middleware): void
     {
         $kernel = $this->app[Kernel::class];
-        $kernel->pushMiddleware(InjectDebugbar::class);
+        $kernel->pushMiddleware($middleware);
     }
 }

classes/WinterDebugbar.php

@@ -1,21 +1,28 @@
 <?php namespace Winter\Debugbar\Classes;
 
-use Barryvdh\Debugbar\LaravelDebugbar;
+use DebugBar\JavascriptRenderer;
+use Fruitcake\LaravelDebugbar\LaravelDebugbar;
 
 class WinterDebugbar extends LaravelDebugbar
 {
     /**
-     * Returns a winterized JavascriptRenderer for this instance
+     * Returns the JavascriptRenderer for this instance with Winter's styling applied.
      *
-     * @param string $baseUrl
-     * @param string $basePathng
-     * @return JavascriptRenderer
+     * Laravel Debugbar 4 performs the renderer configuration inside getJavascriptRenderer(),
+     * so we defer to the parent to build and cache the renderer and then register Winter's
+     * stylesheet via the renderer's asset API (the renderer is cached, so the CSS is only
+     * added the first time it is built).
      */
-    public function getJavascriptRenderer($baseUrl = null, $basePath = null)
+    public function getJavascriptRenderer(?string $baseUrl = null, ?string $basePath = null): JavascriptRenderer
     {
-        if ($this->jsRenderer === null) {
-            $this->jsRenderer = new JavascriptRenderer($this, $baseUrl, $basePath);
+        $alreadyBuilt = $this->jsRenderer !== null;
+
+        $renderer = parent::getJavascriptRenderer($baseUrl, $basePath);
+
+        if (!$alreadyBuilt) {
+            $renderer->addAssets(cssFiles: ['debugbar.css'], basePath: __DIR__ . '/../assets/css');
         }
-        return $this->jsRenderer;
+
+        return $renderer;
     }
 }

collectors/BackendCollector.php

@@ -25,7 +25,7 @@ public function __construct(Controller $controller, $action, array $params = [])
     /**
      * {@inheritDoc}
      */
-    public function collect()
+    public function collect(): array
     {
         $ajaxHandler = $this->controller->getAjaxHandler();
 
@@ -100,15 +100,15 @@ protected function getReflector($handler)
     /**
      * {@inheritDoc}
      */
-    public function getName()
+    public function getName(): string
     {
         return 'backend';
     }
 
     /**
      * {@inheritDoc}
      */
-    public function getWidgets()
+    public function getWidgets(): array
     {
         return [
             'route' => [

collectors/CmsCollector.php

@@ -26,7 +26,7 @@ public function __construct(Controller $controller, $url, Page $page)
     /**
      * {@inheritDoc}
      */
-    public function collect()
+    public function collect(): array
     {
         $ajaxHandler = $this->controller->getAjaxHandler();
 
@@ -103,15 +103,15 @@ protected function getReflector($handler)
     /**
      * {@inheritDoc}
      */
-    public function getName()
+    public function getName(): string
     {
         return 'cms';
     }
 
     /**
      * {@inheritDoc}
      */
-    public function getWidgets()
+    public function getWidgets(): array
     {
         return [
             'route' => [

collectors/ComponentsCollector.php

@@ -28,7 +28,7 @@ public function __construct(Controller $controller, Page $page, Layout $layout)
     /**
      * {@inheritDoc}
      */
-    public function collect()
+    public function collect(): array
     {
         /** @var ComponentBase[]|object $components */
         $components = [];
@@ -58,15 +58,15 @@ protected function makeComponentDetails($componentObj): array
     /**
      * {@inheritDoc}
      */
-    public function getName()
+    public function getName(): string
     {
         return 'components';
     }
 
     /**
      * {@inheritDoc}
      */
-    public function getWidgets()
+    public function getWidgets(): array
     {
         return [
             'components' => [

composer.json

@@ -23,9 +23,9 @@
         "source": "https://github.com/wintercms/wn-debugbar-plugin"
     },
     "require": {
-        "php": ">=7.0",
+        "php": ">=8.3",
         "composer/installers": "~1.0",
-        "barryvdh/laravel-debugbar": "^3.15.0"
+        "barryvdh/laravel-debugbar": "^4.2"
     },
     "replace": {
         "rainlab/debugbar-plugin": ">=1.0.5"

middleware/InjectDebugbar.php

@@ -3,14 +3,51 @@
 namespace Winter\Debugbar\Middleware;
 
 use Backend\Facades\BackendAuth;
-use Barryvdh\Debugbar\Middleware\InjectDebugbar as BaseMiddleware;
 use Closure;
+use Fruitcake\LaravelDebugbar\LaravelDebugbar;
+use Illuminate\Foundation\Application;
 use Symfony\Component\HttpFoundation\Request;
 use Throwable;
 use Winter\Storm\Support\Facades\Config;
 
-class InjectDebugbar extends BaseMiddleware
+/**
+ * Injects the Debugbar into the response, gated by the winter.debugbar permissions.
+ *
+ * Laravel Debugbar 4 removed its own InjectDebugbar middleware in favour of a
+ * RequestHandled event listener (registered by the base ServiceProvider) that injects
+ * the Debugbar unconditionally. This middleware replicates the legacy behaviour: it boots
+ * the Debugbar, restricts request storage and injection to authorised users, and performs
+ * the response handling itself via LaravelDebugbar::handleResponse(). Because handleResponse()
+ * flags the response as modified, the base event listener becomes a no-op for this request.
+ */
+class InjectDebugbar
 {
+    /**
+     * The Laravel Application
+     *
+     * @var Application
+     */
+    protected $app;
+
+    /**
+     * The Debugbar instance
+     *
+     * @var LaravelDebugbar
+     */
+    protected $debugbar;
+
+    /**
+     * Create a new middleware instance.
+     *
+     * @param  Application     $app
+     * @param  LaravelDebugbar $debugbar
+     */
+    public function __construct(Application $app, LaravelDebugbar $debugbar)
+    {
+        $this->app = $app;
+        $this->debugbar = $debugbar;
+    }
+
     /**
      * Handle an incoming request.
      *
@@ -20,18 +57,14 @@ class InjectDebugbar extends BaseMiddleware
      */
     public function handle($request, Closure $next)
     {
-        if (!$this->debugbar->isEnabled() || $this->inExceptArray($request)) {
+        if (!$this->debugbar->isEnabled() || $this->debugbar->requestIsExcluded($request)) {
             return $next($request);
         }
 
         $this->debugbar->boot();
 
-        try {
-            /** @var \Illuminate\Http\Response $response */
-            $response = $next($request);
-        } catch (Throwable $e) {
-            $response = $this->handleException($request, $e);
-        }
+        /** @var \Illuminate\Http\Response $response */
+        $response = $next($request);
 
         // Database table might not exist yet
         try {
@@ -49,14 +82,21 @@ public function handle($request, Closure $next)
             $this->debugbar->setStorage(null);
         }
 
-        // Modify the response to add the Debugbar if allowed
+        // Only inject the Debugbar into the response if the user is allowed to view it
         if (
-            ($user && $user->hasAccess('winter.debugbar.access_debugbar')) ||
-            Config::get('winter.debugbar::allow_public_access', false)
+            !($user && $user->hasAccess('winter.debugbar.access_debugbar')) &&
+            !Config::get('winter.debugbar::allow_public_access', false)
         ) {
-            $this->debugbar->modifyResponse($request, $response);
+            // Prevent the visual Debugbar from being injected while still allowing
+            // permitted requests to be stored (handled by setStorage above)
+            Config::set('debugbar.inject', false);
         }
 
+        // Modify the response to add the Debugbar (and store the request, when permitted).
+        // This flags the response as modified, so the base ServiceProvider's RequestHandled
+        // listener will skip re-processing it.
+        $this->debugbar->handleResponse($request, $response);
+
         return $response;
     }
 }